TEXPRE.PAS[TEX,ALS] - www.SailDart.org

perm filename TEXPRE.PAS[TEX,ALS] blob sn#606698 filedate 1981-08-19 generic text, type T, neo UTF8
(* TEX STANFORD CS AUGUST 1981.
TEX WAS DESIGNED BY DONALD E. KNUTH,
WHO INITIALLY IMPLEMENTED IT IN SAIL.
THIS PASCAL VERSION OF TEX
IS DUE TO IGNACIO A. ZABALA. *)
PROGRAM TEXPRE;
LABEL 100;
TYPE ASCIICODE= 0..127;
SHORTASCIICODE= 0..31;
ASCIISTRING= ARRAY[0..63] OF
ASCIICODE;
ONEOFTWO= 1..2;
ONEOFTHREE= 1..3;
ONEOFFOUR= 1..4;
ONEOFFIVE= 1..5;
ONEOFSIX= 1..6;
PAGEMEMARRAY= ARRAY[0..7] OF
REAL;
HALVES2= PACKED RECORD
LHWORD: 0..65535;
CASE ONEOFTWO OF
1:(RHWORD: 0..65535);
2:(BYTE2: 0..255;
BYTE3: 0..255)
END;
BYTES4= PACKED RECORD
BYTE0: 0..255;
BYTE1: 0..255;
CASE ONEOFTWO OF
1:(RHWORD: 0..65535);
2:(BYTE2: 0..255;
BYTE3: 0..255)
END;
MEMORYWORD= PACKED RECORD CASE
ONEOFFOUR OF
1:(PTS: REAL);
2:(INT: INTEGER);
3:(TWOHALVES: HALVES2);
4:(FOURBYTES: BYTES4)
END;
MEMARRAY= ARRAY[0..49152] OF
MEMORYWORD;
HASHARRAY= ARRAY[23..1009] OF
HALVES2;
HHEADARRAY= ARRAY[0..88] OF
INTEGER;
EQTBARRAY= ARRAY[0..1428] OF
MEMORYWORD;
BUFFIR= ARRAY[1..200] OF ASCIICODE;
INPUTSTATE= RECORD
BUFFER: BUFFIR;
BUFPTR: INTEGER;
CURBUF: INTEGER;
STATE: INTEGER;
LOC: INTEGER;
RECOVERY: HALVES2;
LVL: INTEGER END;
WARNSTATE=(OK, DEFOF, USEOF,
PREAMBLEOF);
RAWEXCEPTION=PACKED ARRAY[1..20]
OF CHAR;
EXCEPTION=PACKED ARRAY[1..12]
OF SHORTASCIICODE;

HYPHENBITS=SET OF 1..16;
PCKDHYPHBITS=PACKED SET OF 1..16;
PACKEDALPHAS=PACKED SET OF 0..26
;

PCKDCONSPAIR=PACKED RECORD
HCHAR:0..7;
WEAK:0..7;
ALPHASET:PACKEDALPHAS
END;

OPCODE=0..15;
TRUTHX=0..255;
HOPERAND=0..255;
SUFFIXTP=PACKED RECORD
CODE: OPCODE;
CASE ONEOFTWO OF
1:(TRUEX:TRUTHX;
FALSEX:TRUTHX;
OPRAND:HOPERAND);
2:(ALPHASET:PACKEDALPHAS)
END;
PREFIXTP=SUFFIXTP;
TBLREADOUTTYPE= RECORD CASE ONEOFSIX
OF
1:(EXCPTBLVARIANT:EXCEPTION);
2:(EXCPHYPHVARIANT:PCKDHYPHBITS);
3:(SUFFIXVARIANT:SUFFIXTP);
4:(PREFIXVARIANT:PREFIXTP);
5:(BTABLEVARIANT:PCKDCONSPAIR);
6:(READOUTVARIANT:ARRAY[1..3]
OF INTEGER)
END;
EXCPARRAY= ARRAY[0..372] OF
EXCEPTION;
EXCPHYARRAY= ARRAY[1..372] OF
PCKDHYPHBITS;
SUFFIXARRAY= ARRAY[0..115] OF
SUFFIXTP;
PREFIXARRAY= ARRAY[0..108] OF
PREFIXTP;
BARRAY= ARRAY[2..31] OF PCKDCONSPAIR;
DELIMARRAY= ARRAY[0..127] OF
BYTES4;
FNTINFOARRAY= ARRAY[0..63,0..127]
OF BYTES4;
FMEMARRAY= ARRAY[0..6399] OF
MEMORYWORD;
FBASEARRAY= ARRAY[0..63] OF
INTEGER;
FPFIARRAY= ARRAY[0..63,1..5]
OF BYTES4;
VAR CURNODE: INTEGER;
SAVEDBOX: ARRAY[48..58] OF INTEGER;
SAVEDPAGE: INTEGER;
MODE: INTEGER;
PAGEMEM: PAGEMEMARRAY;
MEM: MEMARRAY;
ROVER: INTEGER;
CURCMD: INTEGER;
CURCHAR: INTEGER;
CURFONT: INTEGER;
HASH: HASHARRAY;
HHEAD: HHEADARRAY;
EQTB: EQTBARRAY;
ESCAPECHAR: ASCIICODE;
CURLEV: INTEGER;
SAVESTACK:ARRAY[0..302] OF MEMORYWORD;
SAVEPTR: INTEGER;
HASHENTRY: INTEGER;
NONEWCONTROLSEQ:BOOLEAN;
INSTACK: ARRAY[0..80] OF INPUTSTATE;
INPTR: INTEGER;
CURINPUT: INPUTSTATE;
BRCHAR: ASCIICODE;
EOFF: BOOLEAN;
PARSTACK:ARRAY[0..25] OF INTEGER;
PARPTR: INTEGER;
PSTACK: ARRAY[0..25] OF INTEGER;
ALIGNSTATE: INTEGER;
KOUNT: ARRAY[48..57] OF INTEGER;
OUTPUTDORMANT: BOOLEAN;
TOPMARK,BOTMARK,FIRSTMARK: INTEGER;
PAGEWARNING: WARNSTATE;
WARNINDEX: INTEGER;
TOKSTRING: PACKED ARRAY[0..1,1..700]
OF ASCIICODE;
TOKSPTR: ARRAY[0..1] OF INTEGER;
NOOUTPUTYET: BOOLEAN;
PAUSINGONERRORS: BOOLEAN;
ERRCNT: INTEGER;
NOTNONSTOP: BOOLEAN;
DELETSALLOWED: BOOLEAN;
Q: INTEGER;
TOKTYP, TOKVAL: INTEGER;
HASHPAR, HASHSEND: INTEGER;
CURTYP, CURVAL: INTEGER;
NBRLENGTH: INTEGER;
NBRSIGN: ASCIICODE;
CHARTOASC: PACKED ARRAY[CHAR]
OF 0..127;
EXCEPTABLE: EXCPARRAY;
EXCEPHYPH: EXCPHYARRAY;
SUFFIX: SUFFIXARRAY;
PREFIX: PREFIXARRAY;
BTABLE: BARRAY;
READOUTVARIABLE:TBLREADOUTTYPE;
NULWORD:EXCEPTION;
EXCEPTIONS:ARRAY[1..373] OF RAWEXCEPTION;
DELIMTABLE: DELIMARRAY;
FONTINFO: FNTINFOARRAY;
FMEM: FMEMARRAY;
FMEMPTR: INTEGER;
WDBASE: FBASEARRAY;
HTBASE: FBASEARRAY;
DPBASE: FBASEARRAY;
ICBASE: FBASEARRAY;
LGBASE: FBASEARRAY;
KRBASE: FBASEARRAY;
EXTBASE: FBASEARRAY;
PARBASE: FBASEARRAY;
FCKSUM: FBASEARRAY;
FPFB: FBASEARRAY;
FMAG: FBASEARRAY;
FPFI: FPFIARRAY;
SUPTABLE: ARRAY[0..7] OF INTEGER;
K,J: INTEGER;
NFNTS: INTEGER;
NONMU: BOOLEAN;
ROMVAL: ARRAY[1..7] OF INTEGER;
ROMLET: ARRAY[1..7] OF ASCIICODE;
FOURBYTESIZE: INTEGER;
INITPROCEDURE;

BEGIN
EXCEPTIONS[1]:='AP1PRE1CI2ABLE000000';
EXCEPTIONS[2]:='CON1TROL21LABLE00000';
EXCEPTIONS[3]:='UN1CON1TR2OLLABLE000';
EXCEPTIONS[4]:='FLAM1MAB2LE000000000';
EXCEPTIONS[5]:='IN1FLAM1A2BLE0000000';
EXCEPTIONS[6]:='IN1ES1TI1A2BLE000000';
EXCEPTIONS[7]:='FOR1MI1DA2BLE0000000';
EXCEPTIONS[8]:='POR1TABL2E0000000000';
EXCEPTIONS[9]:='IM1PREG1N2ABLE000000';
EXCEPTIONS[10]:='EQ1UABLE200000000000';
EXCEPTIONS[11]:='IN1SA1TIA2BLE0000000';
EXCEPTIONS[12]:='NE1GO1TIA2BLE0000000';
EXCEPTIONS[13]:='SO1CIABL2E0000000000';
EXCEPTIONS[14]:='TURN1TAB2LE000000000';
EXCEPTIONS[15]:='UN1SO1CIA2BLE0000000';
EXCEPTIONS[16]:='CON1STAB2LE000000000';
EXCEPTIONS[17]:='STABLE00000000000000';
EXCEPTIONS[18]:='UN1STABL2E0000000000';
EXCEPTIONS[19]:='WORK1TAB2LE000000000';
EXCEPTIONS[20]:='DE1PEN1DE2NT00000000';
EXCEPTIONS[21]:='IN1DE1PEN2DENT000000';
EXCEPTIONS[22]:='ANY1THIN2G0000000000';
EXCEPTIONS[23]:='DAR1LING200000000000';
EXCEPTIONS[24]:='DUMP1LIN2G0000000000';
EXCEPTIONS[25]:='EVE1NING200000000000';
EXCEPTIONS[26]:='EVERY1TH2ING00000000';
EXCEPTIONS[27]:='FAR1THIN2G0000000000';
EXCEPTIONS[28]:='FOUND1LI2NG000000000';
EXCEPTIONS[29]:='INK1LING200000000000';
EXCEPTIONS[30]:='MAIN1SPR2ING00000000';
EXCEPTIONS[31]:='OFF1SPRI2NG000000000';
EXCEPTIONS[32]:='PLAY1THI2NG000000000';
EXCEPTIONS[33]:='SAP1LING200000000000';
EXCEPTIONS[34]:='SHOE1STR2ING00000000';
EXCEPTIONS[35]:='SIB1LING200000000000';
EXCEPTIONS[36]:='SOME1THI2NG000000000';
EXCEPTIONS[37]:='STAR1LIN2G0000000000';
EXCEPTIONS[38]:='STER1LIN2G0000000000';
EXCEPTIONS[39]:='UN1ERR1IN2G000000000';
EXCEPTIONS[40]:='UP1SWING200000000000';
EXCEPTIONS[41]:='WEAK1LIN2G0000000000';
EXCEPTIONS[42]:='YEAR1LIN2G0000000000';
EXCEPTIONS[43]:='IN1FRING2ED000000000';
EXCEPTIONS[44]:='CIV1I1LIZ2E000000000';
EXCEPTIONS[45]:='CRYS1TAL21LIZE000000';
EXCEPTIONS[46]:='IM1MO1BI1L2IZE000000';
EXCEPTIONS[47]:='MO1BI1LIZ2E000000000';
EXCEPTIONS[48]:='MO1NOP1O1L2IZE000000';
EXCEPTIONS[49]:='STA1BI1LIZ2E00000000';
EXCEPTIONS[50]:='TAN1TA1LI2ZE00000000';
EXCEPTIONS[51]:='UN1CIV1I1L2IZED00000';
EXCEPTIONS[52]:='UTI1LIZE200000000000';
EXCEPTIONS[53]:='PAL1ATE0000000000000';
EXCEPTIONS[54]:='IN1CLEM1E2NT00000000';
EXCEPTIONS[55]:='BAR1ON1ES2S000000000';
EXCEPTIONS[56]:='LI1ON1ESS20000000000';
EXCEPTIONS[57]:='EU1LOGY0000000000000';
EXCEPTIONS[58]:='PED1A1GOG2Y000000000';
EXCEPTIONS[59]:='LUS1CIOU2S0000000000';
EXCEPTIONS[60]:='MET1AL00000000000000';
EXCEPTIONS[61]:='NON1META2L0000000000';
EXCEPTIONS[62]:='PET1AL00000000000000';
EXCEPTIONS[63]:='POSTAL00000000000000';
EXCEPTIONS[64]:='RENT1AL0000000000000';
EXCEPTIONS[65]:='CAT1ION0000000000000';
EXCEPTIONS[66]:='COM1BAT1I2VE00000000';
EXCEPTIONS[67]:='STAT1URE200000000000';
EXCEPTIONS[68]:='BECK1ON0000000000000';
EXCEPTIONS[69]:='BECK1ONE2D0000000000';
EXCEPTIONS[70]:='BES1TIAL200000000000';
EXCEPTIONS[71]:='COME1BAC2K0000000000';
EXCEPTIONS[72]:='CO1ME1DIA2N000000000';
EXCEPTIONS[73]:='COMP1TRO2LLER0000000';
EXCEPTIONS[74]:='CONE1FLO2WER00000000';
EXCEPTIONS[75]:='CO1NUN1DR2UM00000000';
EXCEPTIONS[76]:='EQUIPPE2D00000000000';
EXCEPTIONS[77]:='HANDLE1B2AR000000000';
EXCEPTIONS[78]:='INCH1WOR2M0000000000';
EXCEPTIONS[79]:='INK1BLOT200000000000';
EXCEPTIONS[80]:='INN1KEEP2ER000000000';
EXCEPTIONS[81]:='IN1TE1RIO2R000000000';
EXCEPTIONS[82]:='MIN1IS1TE2R000000000';
EXCEPTIONS[83]:='MIN1IS1TR2Y000000000';
EXCEPTIONS[84]:='NONE1THE21LESS000000';
EXCEPTIONS[85]:='QUA1DRIL2LE000000000';
EXCEPTIONS[86]:='SOM1ER1SA2ULT0000000';
EXCEPTIONS[87]:='SU1PE1RIO2R000000000';
EXCEPTIONS[88]:='TRAN1SPP2RE000000000';
EXCEPTIONS[89]:='UNA1NIM1I2TY00000000';
EXCEPTIONS[90]:='UNAN1I1MO2US00000000';
EXCEPTIONS[91]:='UNC1TUOU2S0000000000';
EXCEPTIONS[92]:='DEBT1OR0000000000000';
EXCEPTIONS[93]:='AC1KNOWL21EDGE000000';
EXCEPTIONS[94]:='DE1DUCT1IB2LE0000000';
EXCEPTIONS[95]:='VICT1UAL200000000000';
EXCEPTIONS[96]:='NEE1DLE1W2ORK0000000';
EXCEPTIONS[97]:='IDLER000000000000000';
EXCEPTIONS[98]:='OFF1BEAT200000000000';
EXCEPTIONS[99]:='OFF1HAND200000000000';
EXCEPTIONS[100]:='OFF1PRIN2T0000000000';
EXCEPTIONS[101]:='OFF1SET0000000000000';
EXCEPTIONS[102]:='OFF1SET1T2ING0000000';
EXCEPTIONS[103]:='OFF1SHOO2T0000000000';
EXCEPTIONS[104]:='OFF1SHOR2E0000000000';
EXCEPTIONS[105]:='STIFF1EN200000000000';
EXCEPTIONS[106]:='LEFT1IST200000000000';
EXCEPTIONS[107]:='LEFT1OVE2R0000000000';
EXCEPTIONS[108]:='LIFT1OFF200000000000';
EXCEPTIONS[109]:='SOFT1HEA2RTED0000000';
EXCEPTIONS[110]:='EGG1NOG0000000000000';
EXCEPTIONS[111]:='EGG1HEAD200000000000';
EXCEPTIONS[112]:='COGNAC00000000000000';
EXCEPTIONS[113]:='DE1SIGN1E2R000000000';
EXCEPTIONS[114]:='FOR1EIGN21ER00000000';
EXCEPTIONS[115]:='POI1GNAN2T0000000000';
EXCEPTIONS[116]:='VIGNETT2E00000000000';
EXCEPTIONS[117]:='HOGS1HEA2D0000000000';
EXCEPTIONS[118]:='CHILD1IS2H0000000000';
EXCEPTIONS[119]:='GOLD1EN0000000000000';
EXCEPTIONS[120]:='HOLD1OUT200000000000';
EXCEPTIONS[121]:='HOLD1OVE2R0000000000';
EXCEPTIONS[122]:='HOLD1UP0000000000000';
EXCEPTIONS[123]:='SELF1ISH200000000000';
EXCEPTIONS[124]:='SELF1ADJ2OINT0000000';
EXCEPTIONS[125]:='UN1SELF1I2SH00000000';
EXCEPTIONS[126]:='BULL1ISH200000000000';
EXCEPTIONS[127]:='CREST1FA2LLEN0000000';
EXCEPTIONS[128]:='DIS1TILL1E2RY0000000';
EXCEPTIONS[129]:='FALL1OUT200000000000';
EXCEPTIONS[130]:='LULL1ABY200000000000';
EXCEPTIONS[131]:='ROLL1AWA2Y0000000000';
EXCEPTIONS[132]:='SELL1OUT200000000000';
EXCEPTIONS[133]:='SMALL1ES2T0000000000';
EXCEPTIONS[134]:='TALL1EST000000000000';
EXCEPTIONS[135]:='WALL1EYE200000000000';
EXCEPTIONS[136]:='PSALM1IS2T0000000000';
EXCEPTIONS[137]:='ADULT1HO2OD000000000';
EXCEPTIONS[138]:='ELSE1WHE2RE000000000';
EXCEPTIONS[139]:='FALSE1HO2OD000000000';
EXCEPTIONS[140]:='VOLT1AGE200000000000';
EXCEPTIONS[141]:='RE1VOLV1E2R000000000';
EXCEPTIONS[142]:='BEACH1CO2MB1ER000000';
EXCEPTIONS[143]:='BOMB1ER0000000000000';
EXCEPTIONS[144]:='CLIMB1ER200000000000';
EXCEPTIONS[145]:='PLUMB1ER200000000000';
EXCEPTIONS[146]:='DAMP1EN0000000000000';
EXCEPTIONS[147]:='HENCE1FO2RTH00000000';
EXCEPTIONS[148]:='MINCE1ME2AT000000000';
EXCEPTIONS[149]:='BIND1ERY200000000000';
EXCEPTIONS[150]:='BOUND1AR2Y0000000000';
EXCEPTIONS[151]:='FIEND1IS2H0000000000';
EXCEPTIONS[152]:='LAND1OWN2ER000000000';
EXCEPTIONS[153]:='OUT1LAND21ISH0000000';
EXCEPTIONS[154]:='ROUND1AB2OUT00000000';
EXCEPTIONS[155]:='SEND1OFF200000000000';
EXCEPTIONS[156]:='STAND1OU2T0000000000';
EXCEPTIONS[157]:='CHANGE1O2VER00000000';
EXCEPTIONS[158]:='HANG1OUT200000000000';
EXCEPTIONS[159]:='HANG1OVE2R0000000000';
EXCEPTIONS[160]:='ORANGE1A2DE000000000';
EXCEPTIONS[161]:='ANT1ACID200000000000';
EXCEPTIONS[162]:='ANT1EATE2R0000000000';
EXCEPTIONS[163]:='COUNT1ES2S0000000000';
EXCEPTIONS[164]:='REP1RE1SE2NTATIVE000';
EXCEPTIONS[165]:='ANT1HILL200000000000';
EXCEPTIONS[166]:='PENT1HOU2SE000000000';
EXCEPTIONS[167]:='PER1CENT1A2GE0000000';
EXCEPTIONS[168]:='ADAPT1ER200000000000';
EXCEPTIONS[169]:='CRYPT1AN2ALYSIS00000';
EXCEPTIONS[170]:='IN1TER1RUPT1IB2LE000';
EXCEPTIONS[171]:='AN1TIQ1UI2TY00000000';
EXCEPTIONS[172]:='IN1EQ1UIT2Y000000000';
EXCEPTIONS[173]:='IN1IQ1UIT2Y000000000';
EXCEPTIONS[174]:='LIQ1UEFY200000000000';
EXCEPTIONS[175]:='LIQ1UID0000000000000';
EXCEPTIONS[176]:='LIQ1UI1DA2TE00000000';
EXCEPTIONS[177]:='PRE1REQ1U2I1SITE0000';
EXCEPTIONS[178]:='REQ1UI1SI2TION000000';
EXCEPTIONS[179]:='UBIQ1UI1T2OUS0000000';
EXCEPTIONS[180]:='HERBAL00000000000000';
EXCEPTIONS[181]:='ARCH1ANG2EL000000000';
EXCEPTIONS[182]:='RE1SEARC2H1ERS000000';
EXCEPTIONS[183]:='BOARD1ER200000000000';
EXCEPTIONS[184]:='CHORDAL2000000000000';
EXCEPTIONS[185]:='HARD1EN0000000000000';
EXCEPTIONS[186]:='HARD1EST200000000000';
EXCEPTIONS[187]:='HAZ1ARD1O2US00000000';
EXCEPTIONS[188]:='RE1CORD1E2R000000000';
EXCEPTIONS[189]:='STAND1AR2D1IZE000000';
EXCEPTIONS[190]:='STEW1ARD21ESS0000000';
EXCEPTIONS[191]:='YARD1AGE200000000000';
EXCEPTIONS[192]:='NON1CON1F2ORM1IST000';
EXCEPTIONS[193]:='CAV1ERN1O2US00000000';
EXCEPTIONS[194]:='DIS1CERN21IBLE000000';
EXCEPTIONS[195]:='MOD1ERN1I2ZE00000000';
EXCEPTIONS[196]:='TURN1ABO2UT000000000';
EXCEPTIONS[197]:='TURN1OVE2R0000000000';
EXCEPTIONS[198]:='WEST1ERN21IZE0000000';
EXCEPTIONS[199]:='HARP1IST200000000000';
EXCEPTIONS[200]:='SHARP1EN200000000000';
EXCEPTIONS[201]:='IR1RE1VER2S1IBLE0000';
EXCEPTIONS[202]:='NURSE1MA2ID000000000';
EXCEPTIONS[203]:='RE1HEARS21AL00000000';
EXCEPTIONS[204]:='RE1VERS1I2BLE0000000';
EXCEPTIONS[205]:='WORS1EN0000000000000';
EXCEPTIONS[206]:='ART1IST0000000000000';
EXCEPTIONS[207]:='AS1SERT1I2VE00000000';
EXCEPTIONS[208]:='CON1VERT21IBLE000000';
EXCEPTIONS[209]:='COURT1YA2RD000000000';
EXCEPTIONS[210]:='FORE1SHO2RT1EN000000';
EXCEPTIONS[211]:='HEART1AC2HE000000000';
EXCEPTIONS[212]:='HEART1IL2Y0000000000';
EXCEPTIONS[213]:='SHORT1EN200000000000';
EXCEPTIONS[214]:='APART1HE2ID000000000';
EXCEPTIONS[215]:='COURT1HO2USE00000000';
EXCEPTIONS[216]:='EARTH1EN21WARE000000';
EXCEPTIONS[217]:='NORTH1EA2ST000000000';
EXCEPTIONS[218]:='NORTH1ER2N0000000000';
EXCEPTIONS[219]:='PORT1HOL2E0000000000';
EXCEPTIONS[220]:='OB1SERV1E2R000000000';
EXCEPTIONS[221]:='SERV1ER0000000000000';
EXCEPTIONS[222]:='PRE1SCHO2OL000000000';
EXCEPTIONS[223]:='CON1DE1SC2END0000000';
EXCEPTIONS[224]:='CRE1SCEN2DO000000000';
EXCEPTIONS[225]:='DE1CRE1SC2ENDO000000';
EXCEPTIONS[226]:='DE1SCEND21ENT0000000';
EXCEPTIONS[227]:='DE1SCENT200000000000';
EXCEPTIONS[228]:='OM1NI1SCI2ENT0000000';
EXCEPTIONS[229]:='PLEB1I1SC2ITE0000000';
EXCEPTIONS[230]:='RE1SCIND200000000000';
EXCEPTIONS[231]:='SEA1SCAP2E0000000000';
EXCEPTIONS[232]:='ASKANCE2000000000000';
EXCEPTIONS[233]:='SNAKE1SK2IN000000000';
EXCEPTIONS[234]:='WHISK1ER200000000000';
EXCEPTIONS[235]:='COLE1SLA2W0000000000';
EXCEPTIONS[236]:='RATTLE1S2NAKE0000000';
EXCEPTIONS[237]:='CLASS1RO2OM000000000';
EXCEPTIONS[238]:='CROSS1OV2ER000000000';
EXCEPTIONS[239]:='DIS1MISS21AL00000000';
EXCEPTIONS[240]:='EX1PRESS1IB2LE000000';
EXCEPTIONS[241]:='LESS1EN0000000000000';
EXCEPTIONS[242]:='TOSS1UP0000000000000';
EXCEPTIONS[243]:='UN1CLASS21I1FIED0000';
EXCEPTIONS[244]:='AR1MI1STI2CE00000000';
EXCEPTIONS[245]:='ASTIG1MA21TISM000000';
EXCEPTIONS[246]:='ASTIR000000000000000';
EXCEPTIONS[247]:='BLAST1OF2F0000000000';
EXCEPTIONS[248]:='BY1STAND21ER00000000';
EXCEPTIONS[249]:='CANDLE1S2TICK0000000';
EXCEPTIONS[250]:='CAST1AWA2Y0000000000';
EXCEPTIONS[251]:='CAST1OFF200000000000';
EXCEPTIONS[252]:='CO1STAR0000000000000';
EXCEPTIONS[253]:='DI1GEST1I2BLE0000000';
EXCEPTIONS[254]:='EAST1ERN200000000000';
EXCEPTIONS[255]:='FORE1STA2LL000000000';
EXCEPTIONS[256]:='IN1DI1GEST1IB2LE0000';
EXCEPTIONS[257]:='IN1EX1HAU2ST1IBLE000';
EXCEPTIONS[258]:='IR1RE1SIS2T1BLE00000';
EXCEPTIONS[259]:='LIFE1STY2LE000000000';
EXCEPTIONS[260]:='LIME1STO2NE000000000';
EXCEPTIONS[261]:='LIVE1STO2CK000000000';
EXCEPTIONS[262]:='MILE1STO2NE000000000';
EXCEPTIONS[263]:='PHO1TO1ST2AT00000000';
EXCEPTIONS[264]:='RE1START21ED00000000';
EXCEPTIONS[265]:='RE1STATE21MENT000000';
EXCEPTIONS[266]:='RE1STORE200000000000';
EXCEPTIONS[267]:='SHY1STER200000000000';
EXCEPTIONS[268]:='SIDE1STE2P0000000000';
EXCEPTIONS[269]:='SMOKE1ST2ACK00000000';
EXCEPTIONS[270]:='SUG1GEST1IB2LE000000';
EXCEPTIONS[271]:='THERMO1S2TAT00000000';
EXCEPTIONS[272]:='WASTE1BA2S1KET000000';
EXCEPTIONS[273]:='WASTE1LA2ND000000000';
EXCEPTIONS[274]:='MAST1HEA2D0000000000';
EXCEPTIONS[275]:='POST1HU1M2OUS0000000';
EXCEPTIONS[276]:='PRIEST1H2OOD00000000';
EXCEPTIONS[277]:='SIDE1SWI2PE000000000';
EXCEPTIONS[278]:='WATT1MET2ER000000000';
EXCEPTIONS[279]:='BE1TWEEN200000000000';
EXCEPTIONS[280]:='KIB1ITZE2R0000000000';
EXCEPTIONS[281]:='BUZZ1ER0000000000000';
EXCEPTIONS[282]:='AL1GO1RIT2HM00000000';
EXCEPTIONS[283]:='BIB1LI1OG21RAPHY0000';
EXCEPTIONS[284]:='BI1NO1MIA2L000000000';
EXCEPTIONS[285]:='CAT1E1GO1R2Y00000000';
EXCEPTIONS[286]:='CEN1TER0000000000000';
EXCEPTIONS[287]:='COM1PUT1AB2IL1ITY000';
EXCEPTIONS[288]:='DEC1LA1RA21TION00000';
EXCEPTIONS[289]:='DE1GREE0000000000000';
EXCEPTIONS[290]:='ES1TAB1LI2SH00000000';
EXCEPTIONS[291]:='HAP1HAZA2RD000000000';
EXCEPTIONS[292]:='NEG1LI1GI2BLE0000000';
EXCEPTIONS[293]:='PE1RI1ODI2C000000000';
EXCEPTIONS[294]:='POLY1NO1M2IAL0000000';
EXCEPTIONS[295]:='PRE1VIOU2S0000000000';
EXCEPTIONS[296]:='PRO1CE1DU2RE00000000';
EXCEPTIONS[297]:='PROB1ABL2E0000000000';
EXCEPTIONS[298]:='PROB1ABI2L1ITY000000';
EXCEPTIONS[299]:='PROB1LEM21ATIC000000';
EXCEPTIONS[300]:='PRO1GRAM21MING000000';
EXCEPTIONS[301]:='PUB1LI1CA21TION00000';
EXCEPTIONS[302]:='PUB1LISH200000000000';
EXCEPTIONS[303]:='REF1ER1ENC2E00000000';
EXCEPTIONS[304]:='RE1PLACE21MENT000000';
EXCEPTIONS[305]:='SUB1SEQUENC2E0000000';
EXCEPTIONS[306]:='WHEN1EVE2R0000000000';
EXCEPTIONS[307]:='00000000000000000000';
SUPTABLE[0]:= 12;
SUPTABLE[1]:= 13;
SUPTABLE[2]:= 13;
SUPTABLE[3]:= 13;
SUPTABLE[4]:= 14;
SUPTABLE[5]:= 14;
SUPTABLE[6]:= 14;
SUPTABLE[7]:= 14;
ROMVAL[1]:=1000;
ROMVAL[2]:=500;
ROMVAL[3]:=100;
ROMVAL[4]:=50;
ROMVAL[5]:=10;
ROMVAL[6]:=5;
ROMVAL[7]:=1;
ROMLET[1]:=109;
ROMLET[2]:=100;
ROMLET[3]:=99;
ROMLET[4]:=108;
ROMLET[5]:=120;
ROMLET[6]:=118;
ROMLET[7]:=105;
END;
PROCEDURE INITSYSDEP(VAR FOURBYTESIZE:
INTEGER);
EXTERN;

PROCEDURE INITSTRINGS;
EXTERN;

PROCEDURE PRODUCESTRING(C: INTEGER;
VAR NAMESTRING: ASCIISTRING);
EXTERN;

FUNCTION APPNDSTRING(D,S:INTEGER):
INTEGER;
EXTERN;

FUNCTION APPNDREAL(D:INTEGER;
S:REAL): INTEGER;
EXTERN;

PROCEDURE RELEASE(FYL: INTEGER);
EXTERN;

FUNCTION INCHTER: ASCIICODE;
EXTERN;

PROCEDURE INLNTER(VAR BUFFER:
BUFFIR;
VAR BUFPTR: INTEGER;
VAR BRCHAR: ASCIICODE);
EXTERN;

PROCEDURE OUTCHERR(C: ASCIICODE);
EXTERN;

PROCEDURE OUTLNERR;
EXTERN;

PROCEDURE SENDCH(STREAM: INTEGER;
C: ASCIICODE);
EXTERN;

PROCEDURE SENDLN(STREAM: INTEGER);
EXTERN;

FUNCTION SENDSTARTED(STREAM: INTEGER):
BOOLEAN;
EXTERN;

PROCEDURE CLOSE(STREAM: INTEGER);
EXTERN;

PROCEDURE PRINT(MES: INTEGER);
EXTERN;

PROCEDURE PRINTLN(MES: INTEGER);
EXTERN;

PROCEDURE PRINTINT(N: INTEGER);
EXTERN;

PROCEDURE PRINTREAL(X: REAL);
EXTERN;

PROCEDURE PRINTOCTAL(N: INTEGER);
EXTERN;

PROCEDURE PRINTFILENAME(FYL: INTEGER);
EXTERN;

PROCEDURE FORCEBUFFEROUT;
EXTERN;

PROCEDURE INLN(FYL: INTEGER;
VAR BUFFER: BUFFIR;
VAR BUFPTR: INTEGER;
VAR BRCHAR: ASCIICODE;
VAR EOFF: BOOLEAN);
EXTERN;

FUNCTION GETFIRSTLINE(FYL: INTEGER;
VAR BUFFER: BUFFIR;
VAR BUFPTR: INTEGER;
VAR BRCHAR: ASCIICODE;
VAR EOFF: BOOLEAN;
VAR PAGE: INTEGER): BOOLEAN;
EXTERN;

PROCEDURE TRACELINE(VAR BUFFER:
BUFFIR;
VAR BUFPTR: INTEGER);
EXTERN;

PROCEDURE DECLAREOFIL(FYL: INTEGER);
EXTERN;

FUNCTION INITFILENAME(FNUM: INTEGER):
INTEGER;
EXTERN;

FUNCTION APPENDTONAME(CMMD, CH:
INTEGER): INTEGER;
EXTERN;

FUNCTION READFONTINFO(FYL: INTEGER;
VAR FONTINFO: FNTINFOARRAY;
VAR FMEM: FMEMARRAY;
VAR WDBASE,HTBASE,DPBASE,ICBASE,LGBASE,KRBASE,EXTBASE,PARBASE:
FBASEARRAY;
VAR FCKSUM,FPFB,FMAG: FBASEARRAY;
VAR FPFI: FPFIARRAY;
VAR FMEMPTR: INTEGER;
PSIZE: REAL;
ATCLAUSE: BOOLEAN): INTEGER;
EXTERN;

PROCEDURE SETTABLESIZES;
EXTERN;

PROCEDURE WRITESECONDMEM(VAR MEM:
MEMARRAY);
EXTERN;

PROCEDURE WRITEEQTB(VAR EQTB:
EQTBARRAY;
VAR HASH: HASHARRAY;
VAR HHEAD: HHEADARRAY;
VAR HASHPAR: INTEGER;
VAR HASHSEND: INTEGER);
EXTERN;

PROCEDURE WRITEHYPHENTB(VAR READOUTVARIABLE:
TBLREADOUTTYPE;
VAR EXCEPTABLE: EXCPARRAY;
VAR EXCEPHYPH: EXCPHYARRAY;
VAR SUFFIX: SUFFIXARRAY;
VAR PREFIX: PREFIXARRAY;
VAR BTABLE: BARRAY);
EXTERN;

PROCEDURE WRITEPAGETB(VAR PAGEMEM:
PAGEMEMARRAY);
EXTERN;

PROCEDURE WRITEDELIMTB(VAR DELIMTABLE:
DELIMARRAY);
EXTERN;

PROCEDURE WRITEFMEM(VAR FMEM:
FMEMARRAY;
VAR WDBASE,HTBASE,DPBASE,ICBASE,LGBASE,KRBASE,EXTBASE,PARBASE:
FBASEARRAY;
VAR FONTINFO: FNTINFOARRAY;
VAR FCKSUM,FPFB,FMAG: FBASEARRAY;
VAR FPFI: FPFIARRAY;
VAR FMEMPTR: INTEGER);
EXTERN;

PROCEDURE DUMPCONTEXT;
FORWARD;
PROCEDURE BACKINPUT;
FORWARD;
PROCEDURE PUSHINPUT;
FORWARD;
PROCEDURE POPINPUT;
FORWARD;
PROCEDURE ALIGNDELIM;
BEGIN END;
PROCEDURE GETNEXT;
FORWARD;
PROCEDURE GETNCNEXT;
FORWARD;
PROCEDURE GETTOK;
FORWARD;
PROCEDURE GETNCTOK;
FORWARD;
FUNCTION SCANTOKS: INTEGER;
FORWARD;
PROCEDURE DUMPTOKENS(P: INTEGER);
FORWARD;
PROCEDURE MACROCALL;
FORWARD;
FUNCTION SCANSTRING(PARTICLE:
INTEGER): BOOLEAN;
FORWARD;
FUNCTION SCANLENGTH: REAL;
FORWARD;
PROCEDURE QUIT;
BEGIN
GOTO 100;
END;
PROCEDURE ERROR;
LABEL 0;

VAR C: ASCIICODE;
J: INTEGER;
BEGIN
DUMPCONTEXT;
IF PAUSINGONERRORS THEN BEGIN

WHILE TRUE DO BEGIN
PRINTLN(94);
C:=INCHTER;
OUTCHERR(C);
IF C=13 THEN GOTO 0;
BEGIN
IF(C>=65) AND(C<=90) THEN
C:=C+32
END;
IF(C=99) THEN GOTO 0;
IF(C=10) OR(C=115) THEN
BEGIN PAUSINGONERRORS:=FALSE;
GOTO 0
END;
IF(C=12) OR(C=115) THEN
BEGIN NOTNONSTOP:=FALSE;
PAUSINGONERRORS:=FALSE;
GOTO 0
END;
IF C=105 THEN BEGIN
PUSHINPUT;
PRINTLN(42);
WITH CURINPUT DO
BEGIN STATE:= 1;
LOC:=-1;
INLNTER(BUFFER,BUFPTR,BRCHAR);
CURBUF:=1;
BUFPTR:=BUFPTR-1
END;
WITH CURINPUT DO FOR J:=CURBUF
TO BUFPTR-1 DO OUTCHERR(BUFFER[J]);
OUTLNERR;
GOTO 0
END;

IF C=120 THEN
BEGIN PRINTLN(543);
C:=INCHTER;
IF(C=120) OR(C=88) THEN QUIT;
END;
IF((C>=48) AND(C<=57))
AND DELETSALLOWED THEN
BEGIN
BEGIN
C:=C-48;
WHILE C>0 DO
BEGIN
GETNEXT;
C:= C-1
END
END;

DUMPCONTEXT END
ELSE BEGIN
PRINTLN(544);
IF DELETSALLOWED THEN
PRINTLN(545);
PRINTLN(546);
END
END;
0:
END
ELSE BEGIN
ERRCNT:=ERRCNT+1;

IF ERRCNT>=100 THEN
BEGIN PRINTLN(547);
GOTO 100;
END;
END;
END;
PROCEDURE OVERFLOW(S: INTEGER;
N: INTEGER);
BEGIN
PAUSINGONERRORS:=FALSE;
PRINTLN(548);
PRINT(S);
PRINTINT(N);
PRINT(549);
ERROR;
QUIT
END;
PROCEDURE CONFUSION;
BEGIN
PAUSINGONERRORS:=FALSE;
PRINTLN(550);
ERROR;
QUIT;
END;
PROCEDURE MUSTQUIT;
BEGIN
PAUSINGONERRORS:=FALSE;
PRINTLN(551);
ERROR;
QUIT;
END;
PROCEDURE INITMEM;
VAR I,F: INTEGER;
BEGIN(* DYNUSED:=0;
VARUSED:=0;
FOR I:=(30+((64)*4))
TO 24999 DO WASFREE[I]:=TRUE;
FOR I:=25012 TO 49151 DO WASFREE[I]:=TRUE;*)
MEM[0].TWOHALVES.RHWORD:=50000;
MEM[0+2].PTS:=10000000000.0;
MEM[0+1].PTS:=0.0;
MEM[0+3].PTS:=0.0;
MEM[4].TWOHALVES.RHWORD:=50000;
MEM[4+2].PTS:=100000.0;
MEM[4+1].PTS:=0.0;
MEM[4+3].PTS:=0.0;
MEM[8].TWOHALVES.RHWORD:=50000;
MEM[8+2].PTS:=-MEM[4+2].PTS
;
MEM[8+1].PTS:=0.0;
MEM[8+3].PTS:=0.0;
MEM[12].TWOHALVES.RHWORD:=50000;
MEM[12+2].PTS:=100000.0;
MEM[12+3].PTS:=100000.0;
MEM[12+1].PTS:=0.0;
MEM[16].TWOHALVES.RHWORD:=50000;
MEM[16+1].PTS:=0.0;
MEM[16+2].PTS:=0.0;
MEM[16+3].PTS:=0.0;
MEM[20].TWOHALVES.LHWORD:=0;
MEM[24].TWOHALVES.LHWORD:=0;
MEM[16+1].PTS:=0.0;
MEM[16+2].PTS:=0.0;
MEM[16+3].PTS:=0.0;
F:=30;
FOR I:=0 TO 63 DO
BEGIN MEM[F].TWOHALVES.RHWORD:=0;
MEM[F+1].PTS:=0.0;
MEM[F+2].PTS:=0.0;
MEM[F+3].PTS:=0.0;
F:=F+4
END;

MEM[(30+((64)*4))+1].TWOHALVES.LHWORD:=(30+((64)*4));
MEM[(30+((64)*4))].TWOHALVES.LHWORD:=(30+((64)*4));
MEM[(30+((64)*4))].TWOHALVES.RHWORD:=65535;
MEM[(30+((64)*4))+1].TWOHALVES.RHWORD:=25000-(30+((64)*4));
ROVER:=(30+((64)*4));

MEM[25000].TWOHALVES.RHWORD:=0;;

MEM[25000].TWOHALVES.LHWORD:=0;
MEM[25001].TWOHALVES.LHWORD:=0;
MEM[25002].TWOHALVES.LHWORD:=0;
MEM[25003].TWOHALVES.LHWORD:=0;
MEM[25004].TWOHALVES.LHWORD:=0;
MEM[25005].TWOHALVES.LHWORD:=0;
MEM[25006].TWOHALVES.LHWORD:=0;
MEM[25007].TWOHALVES.LHWORD:=0;
MEM[25008].TWOHALVES.LHWORD:=0;
MEM[25009].TWOHALVES.LHWORD:=0;

FOR I:=25012 TO 49151 DO MEM[I+1].TWOHALVES
.LHWORD:=I;
MEM[25012].TWOHALVES.LHWORD:=0;

END;
FUNCTION GETNODE(SIZE: INTEGER):
INTEGER;
LABEL 0, 1;
VAR P:INTEGER;
Q:INTEGER;
S: INTEGER;
BEGIN
P:= ROVER;
REPEAT
BEGIN
Q:=P+MEM[P+1].TWOHALVES.RHWORD;
WHILE(MEM[Q].TWOHALVES.RHWORD=65535) DO
BEGIN
BEGIN
IF(Q=ROVER) THEN
BEGIN ROVER:=MEM[Q].TWOHALVES
.LHWORD;

IF(Q=ROVER) THEN GOTO 0
END;
MEM[MEM[Q].TWOHALVES.LHWORD+1].TWOHALVES.LHWORD:=MEM[Q+1].TWOHALVES.LHWORD;
MEM[MEM[Q+1].TWOHALVES.LHWORD].TWOHALVES.LHWORD:=MEM[Q].TWOHALVES.LHWORD;

MEM[Q].TWOHALVES.RHWORD:=0 END;
Q:=Q+MEM[Q+1].TWOHALVES.RHWORD
END;

S:=Q-P;
IF S>=SIZE+2 THEN BEGIN Q:=Q-SIZE;
MEM[P+1].TWOHALVES.RHWORD:=Q-P;
ROVER:=P;
GOTO 1;
END;

IF S=SIZE THEN BEGIN
BEGIN
IF(P=ROVER) THEN
BEGIN ROVER:=MEM[P].TWOHALVES
.LHWORD;

IF(P=ROVER) THEN GOTO 0
END;
MEM[MEM[P].TWOHALVES.LHWORD+1].TWOHALVES.LHWORD:=MEM[P+1].TWOHALVES.LHWORD;
MEM[MEM[P+1].TWOHALVES.LHWORD].TWOHALVES.LHWORD:=MEM[P].TWOHALVES.LHWORD;

MEM[P].TWOHALVES.RHWORD:=0 END;
ROVER:=MEM[P].TWOHALVES.LHWORD;
Q:=P;
GOTO 1
END;

MEM[P+1].TWOHALVES.RHWORD:=S;
P:=MEM[P].TWOHALVES.LHWORD
END;
UNTIL P=ROVER;
0:
OVERFLOW(132,25000);
1:
WITH MEM[Q].TWOHALVES
DO BEGIN RHWORD:=0;
LHWORD:=0 END;
MEM[Q+1].TWOHALVES.LHWORD:=0;
GETNODE:=Q;(* VARUSED:=VARUSED+SIZE;*)

END;
PROCEDURE FREENODE(P,SIZE: INTEGER);
VAR Q:INTEGER;
BEGIN
Q:=MEM[ROVER+1].TWOHALVES.LHWORD;
MEM[P+1].TWOHALVES.LHWORD:=Q;
MEM[P].TWOHALVES.LHWORD:=ROVER;
MEM[P+1].TWOHALVES.RHWORD:=SIZE;
MEM[P].TWOHALVES.RHWORD:=65535;
MEM[ROVER+1].TWOHALVES.LHWORD:=P;
MEM[Q].TWOHALVES.LHWORD:=P;(* VARUSED:=VARUSED-SIZE;*)

END;
FUNCTION GETAVAIL: INTEGER;
VAR P: INTEGER;
BEGIN
P:=MEM[49152].TWOHALVES.LHWORD;
IF P<>0 THEN MEM[49152].TWOHALVES
.LHWORD:=MEM[MEM[49152].TWOHALVES.LHWORD].TWOHALVES.LHWORD
ELSE OVERFLOW(133,49152);
MEM[P].TWOHALVES.LHWORD:=0;
GETAVAIL:=P;(* DYNUSED:=DYNUSED+1;*)
END;
PROCEDURE FREEAVAIL(P: INTEGER);
BEGIN
IF P<25012 THEN FREENODE(P,2)
ELSE BEGIN MEM[P].TWOHALVES.LHWORD:=MEM[49152].TWOHALVES.LHWORD;
MEM[49152].TWOHALVES.LHWORD:=P;(* DYNUSED:=DYNUSED-1;*)
END
END;
PROCEDURE DSLIST(P: INTEGER);
VAR Q:INTEGER;
BEGIN
WHILE P<>0 DO
BEGIN Q:=MEM[P].TWOHALVES.LHWORD;
FREEAVAIL(P);
P:=Q
END
END;
PROCEDURE DELRCLINK(P: INTEGER);
BEGIN
IF MEM[P].TWOHALVES.RHWORD<=0 THEN DSLIST(P)
ELSE MEM[P].TWOHALVES.RHWORD:=MEM[P].TWOHALVES.RHWORD-1
END;
PROCEDURE DELGLUELINK(P: INTEGER);
BEGIN
MEM[P].TWOHALVES.RHWORD:=MEM[P].TWOHALVES.RHWORD-1;

IF MEM[P].TWOHALVES.RHWORD<0 THEN FREENODE(P,4)
END;
PROCEDURE INITSAVE;
BEGIN
CURLEV:=1;
SAVEPTR:=0
END;
PROCEDURE EQDESTROY(EQ: MEMORYWORD);
BEGIN
WITH EQ.FOURBYTES
DO
CASE BYTE0
OF
16: DELRCLINK(RHWORD);
18: DELGLUELINK(RHWORD);
OTHERS:
END;

END;
PROCEDURE EQDEFINE(INX,COMD,LINC:INTEGER);
BEGIN
IF(EQTB[INX].FOURBYTES.BYTE1=CURLEV)
THEN EQDESTROY(EQTB[INX])
ELSE IF CURLEV>1 THEN BEGIN
IF(SAVEPTR>=299)
THEN OVERFLOW(134,300);
SAVESTACK[SAVEPTR]:=EQTB[INX];
SAVEPTR:=SAVEPTR+1;

WITH SAVESTACK[SAVEPTR].FOURBYTES
DO
BEGIN BYTE0:=1;
RHWORD:=INX END;
SAVEPTR:=SAVEPTR+1;

END;

WITH EQTB[INX].FOURBYTES
DO
BEGIN BYTE1:=CURLEV;
BYTE0:=COMD;
RHWORD:=LINC
END;

END;
PROCEDURE CHCODEDEF(INX: INTEGER;
VALU: MEMORYWORD);
BEGIN
IF CURLEV>1 THEN BEGIN
IF(SAVEPTR>=299)
THEN OVERFLOW(134,300);
SAVESTACK[SAVEPTR]:=EQTB[INX];
SAVEPTR:=SAVEPTR+1;

WITH SAVESTACK[SAVEPTR].FOURBYTES
DO
BEGIN BYTE0:=1;
RHWORD:=INX END;
SAVEPTR:=SAVEPTR+1;

END;
EQTB[INX]:=VALU
END;
FUNCTION UNSAVE: INTEGER;
LABEL 0;
BEGIN
CURLEV:=CURLEV-1;
IF CURLEV<>0 THEN
BEGIN
WHILE TRUE DO BEGIN
SAVEPTR:=SAVEPTR-1;
WITH SAVESTACK[SAVEPTR].FOURBYTES
DO
CASE BYTE0
OF
0: BEGIN UNSAVE:=RHWORD;
GOTO 0 END;
1: IF(RHWORD<1137) AND(EQTB[RHWORD].FOURBYTES.BYTE1=1) THEN
BEGIN SAVEPTR:=SAVEPTR-1;
EQDESTROY(SAVESTACK[SAVEPTR])
END
ELSE BEGIN
IF RHWORD<1137 THEN EQDESTROY(EQTB[RHWORD]);
SAVEPTR:=SAVEPTR-1;
EQTB[RHWORD]:= SAVESTACK[SAVEPTR]
END;
2: IF EQTB[RHWORD].FOURBYTES.BYTE1<>1 THEN
BEGIN
EQDESTROY(EQTB[RHWORD]);
EQTB[RHWORD].FOURBYTES.BYTE0:=83;
END;
OTHERS:
CONFUSION
END;
END;
0:
END
ELSE
BEGIN
CURLEV:=1;
UNSAVE:=1
END;

END;
PROCEDURE NEWSAVELEVEL(ENDCODE:INTEGER);
BEGIN
IF SAVEPTR>=300 THEN OVERFLOW(135,300);
WITH SAVESTACK[SAVEPTR].FOURBYTES
DO BEGIN BYTE0:=0;
RHWORD:=ENDCODE END;
SAVEPTR:=SAVEPTR+1;
CURLEV:=CURLEV+1;

IF CURLEV>=255 THEN OVERFLOW(136,255)
END;
PROCEDURE IDLOOKUP(SINGLE: BOOLEAN;
CONSEQ, H: INTEGER);
LABEL 0, 50;
VAR Q,R: INTEGER;
BEGIN
IF SINGLE THEN
BEGIN
HASHENTRY:= 1009+CONSEQ;
IF EQTB[HASHENTRY].FOURBYTES.BYTE0<>83 THEN GOTO 50
END
ELSE BEGIN
HASHENTRY:= HHEAD[H];
WHILE(HASHENTRY<1009)
DO
BEGIN Q:=HASH[HASHENTRY].RHWORD;
R:=CONSEQ;
WHILE(MEM[Q].TWOHALVES.BYTE2=MEM[R].TWOHALVES.BYTE2)
AND(MEM[Q].TWOHALVES.BYTE3=MEM[R].TWOHALVES.BYTE3) DO
BEGIN Q:=MEM[Q].TWOHALVES.LHWORD;
R:=MEM[R].TWOHALVES.LHWORD;
IF(Q=0) AND(R=0) THEN BEGIN

DSLIST(CONSEQ);
GOTO 50
END;
IF(Q=0) OR(R=0) THEN GOTO
0
END;
0:
HASHENTRY:=HASH[HASHENTRY].LHWORD

END
END;

IF NONEWCONTROLSEQ THEN
BEGIN
HASHENTRY:=1137;
IF NOT SINGLE THEN DSLIST(CONSEQ);
END
ELSE BEGIN
IF NOT SINGLE THEN
BEGIN
HASHENTRY:=HASH[1009].LHWORD;

IF HASHENTRY<0 THEN OVERFLOW(137,1009);
HASH[1009].LHWORD:=HASH[HASHENTRY].LHWORD;
HASH[HASHENTRY].RHWORD:=CONSEQ;
HASH[HASHENTRY].LHWORD:=HHEAD[H];
HHEAD[H]:=HASHENTRY END;

EQTB[HASHENTRY].FOURBYTES.BYTE1:=CURLEV;
IF CURLEV>1 THEN BEGIN
IF SAVEPTR>=300 THEN OVERFLOW(138,300);
WITH SAVESTACK[SAVEPTR].FOURBYTES
DO BEGIN BYTE0:=2;
RHWORD:=HASHENTRY END;
SAVEPTR:=SAVEPTR+1
END
END;
50:
END;
PROCEDURE CONTROLSEQ;
VAR C: INTEGER;
P,Q,R: INTEGER;
H: INTEGER;
INODDPOSITION: BOOLEAN;
BEGIN
WITH CURINPUT DO
BEGIN
C:=BUFFER[CURBUF];
CURBUF:=CURBUF+1;

IF(EQTB[C+1137].INT=11) AND
(EQTB[BUFFER[CURBUF]+1137].INT
=11)
THEN
BEGIN P:=GETAVAIL;
Q:=P;
INODDPOSITION:=TRUE;
MEM[Q].TWOHALVES.BYTE2:=C;
H:=256*C;
REPEAT
C:=BUFFER[CURBUF];
BEGIN
IF(C>=65) AND(C<=90) THEN
C:=C+32
END;
CURBUF:=CURBUF+1;

INODDPOSITION:=NOT INODDPOSITION;
IF INODDPOSITION THEN
BEGIN
R:=GETAVAIL;
MEM[Q].TWOHALVES.LHWORD:=R;
Q:=R;
H:=H+256*C;
MEM[Q].TWOHALVES.BYTE2:=C;
END
ELSE BEGIN H:=H+C;
MEM[Q].TWOHALVES.BYTE3:=C
END
UNTIL NOT(EQTB[BUFFER[CURBUF]+1137].INT
=11);

IF INODDPOSITION THEN MEM[Q].TWOHALVES
.BYTE3:=0;
H:= ABS(H) MOD 89;
IDLOOKUP(FALSE,P,H);
END
ELSE IDLOOKUP(TRUE,C,0)
END
END;
FUNCTION IDNAME(H:INTEGER): INTEGER;
BEGIN
IF(H>=1136) OR(H<23) THEN IDNAME:=139

ELSE IF H>=1009 THEN IDNAME:=H-1009

ELSE IF HASH[H].RHWORD<1 THEN IDNAME:=140
ELSE IDNAME:=-HASH[H].RHWORD
END;
PROCEDURE SHOWIDNAME(H: INTEGER);
LABEL 0;
VAR ID: INTEGER;
P,CH: INTEGER;
BEGIN
ID:=IDNAME(H);
IF ID>=0 THEN PRINT(ID)
ELSE
BEGIN P:=-ID;
REPEAT PRINT(MEM[P].TWOHALVES
.BYTE2);
CH:=MEM[P].TWOHALVES.BYTE3;
IF CH=0 THEN GOTO 0
ELSE PRINT(CH);
P:=MEM[P].TWOHALVES.LHWORD
UNTIL P=0;
0:
END
END;
PROCEDURE DUMPLIST(P,Q: INTEGER);
LABEL 0;

VAR J: INTEGER;
PARNUM: ASCIICODE;
FIRSTSUBLIST: BOOLEAN;
COMD,VALU: INTEGER;
CONSEQID: INTEGER;
NP: INTEGER;
PROCEDURE APPENDSTRING(STR: INTEGER);
VAR PARTICLE: ASCIISTRING;
PARTINX: INTEGER;
PARTCH: ASCIICODE;
BEGIN
PRODUCESTRING(STR,PARTICLE);
PARTINX:=0;
PARTCH:=PARTICLE[0];
WHILE PARTCH<>0 DO
BEGIN TOKSPTR[J]:=TOKSPTR[J]+1
;
TOKSTRING[J,TOKSPTR[J]]:=PARTCH;
PARTINX:=PARTINX+1;
PARTCH:=PARTICLE[PARTINX]
END
END;

BEGIN
TOKSPTR[0]:=0;
TOKSPTR[1]:=0;
J:=0;
PARNUM:=48;
WHILE P<>0
DO
BEGIN
IF P=Q
THEN J:=1;
IF(P<0) OR(P>=49152)
THEN
BEGIN APPENDSTRING(141);
GOTO 0
END;
WITH MEM[P].TWOHALVES
DO BEGIN COMD:=BYTE2;
VALU:=BYTE3
END;
CASE COMD OF
0: BEGIN BEGIN TOKSPTR[J]:=TOKSPTR[J]+1
;
TOKSTRING[J,TOKSPTR[J]]:= ESCAPECHAR

END;

BEGIN
P:=MEM[P].TWOHALVES.LHWORD;
CONSEQID:=IDNAME(MEM[P].TWOHALVES
.RHWORD);
IF CONSEQID>=0 THEN BEGIN APPENDSTRING(CONSEQID);
IF EQTB[CONSEQID+1137].INT=11
THEN BEGIN TOKSPTR[J]:=TOKSPTR[J]+1
;
TOKSTRING[J,TOKSPTR[J]]:= 32

END
END
ELSE BEGIN NP:=-CONSEQID;
REPEAT
BEGIN TOKSPTR[J]:=TOKSPTR[J]+1
;
TOKSTRING[J,TOKSPTR[J]]:= MEM[NP].TWOHALVES
.BYTE2
END;

IF MEM[NP].TWOHALVES.BYTE3<>0 THEN BEGIN TOKSPTR[J]:=TOKSPTR[J]+1
;
TOKSTRING[J,TOKSPTR[J]]:= MEM[NP].TWOHALVES
.BYTE3
END;

NP:=MEM[NP].TWOHALVES.LHWORD
UNTIL NP=0;
BEGIN TOKSPTR[J]:=TOKSPTR[J]+1
;
TOKSTRING[J,TOKSPTR[J]]:= 32

END
END
END;

END;
14: IF VALU=0 THEN BEGIN BEGIN
TOKSPTR[J]:=TOKSPTR[J]+1;
TOKSTRING[J,TOKSPTR[J]]:= 35

END;

PARNUM:=PARNUM+1;
BEGIN TOKSPTR[J]:=TOKSPTR[J]+1
;
TOKSTRING[J,TOKSPTR[J]]:= PARNUM

END
END
ELSE APPENDSTRING(143);
9: BEGIN BEGIN TOKSPTR[J]:=TOKSPTR[J]+1
;
TOKSTRING[J,TOKSPTR[J]]:= 35

END;
BEGIN TOKSPTR[J]:=TOKSPTR[J]+1
;
TOKSTRING[J,TOKSPTR[J]]:= VALU+49

END
END;
6: BEGIN BEGIN TOKSPTR[J]:=TOKSPTR[J]+1
;
TOKSTRING[J,TOKSPTR[J]]:= 35

END;
BEGIN TOKSPTR[J]:=TOKSPTR[J]+1
;
TOKSTRING[J,TOKSPTR[J]]:= 35

END
END;
10: BEGIN TOKSPTR[J]:=TOKSPTR[J]+1
;
TOKSTRING[J,TOKSPTR[J]]:= 32

END;

15: APPENDSTRING(144);
1,2,3,4,7,8,11,12: BEGIN TOKSPTR[J]:=TOKSPTR[J]+1
;
TOKSTRING[J,TOKSPTR[J]]:= VALU

END;
OTHERS:
APPENDSTRING(145)
END;

IF(TOKSPTR[J]>EQTB[1418].INT
-50) THEN
BEGIN APPENDSTRING(142);
GOTO 0
END;

P:=MEM[P].TWOHALVES.LHWORD
END;
0:
END;
PROCEDURE DUMPTOKENS;
VAR J: INTEGER;
BEGIN
DUMPLIST(P,0);
FOR J:=1 TO TOKSPTR[0] DO PRINT(TOKSTRING[0,J]);
END;
PROCEDURE PUSHINPUT;
BEGIN
IF INPTR>=80 THEN OVERFLOW(146,80);
INSTACK[INPTR]:=CURINPUT;
INPTR:=INPTR+1;

END;
PROCEDURE POPINPUT;
BEGIN
INPTR:=INPTR-1;
CURINPUT:=INSTACK[INPTR];
WITH CURINPUT DO BRCHAR:=BUFFER[BUFPTR];
IF(BRCHAR<>13) AND(BRCHAR<>12)
THEN BRCHAR:=0
END;
PROCEDURE INSLIST(P: INTEGER);
BEGIN
PUSHINPUT;
WITH CURINPUT DO
BEGIN
STATE:=0;
LOC:=P;
RECOVERY.LHWORD:=P;
RECOVERY.RHWORD:=3 END;
END;
PROCEDURE INSRCLIST(L: INTEGER);
BEGIN
PUSHINPUT;
WITH CURINPUT DO
BEGIN
STATE:=0;
LOC:=MEM[L].TWOHALVES.LHWORD;
RECOVERY.LHWORD:=L;
RECOVERY.RHWORD:=4;
CURBUF:=PARPTR;
END;
MEM[L].TWOHALVES.RHWORD:=MEM[L].TWOHALVES.RHWORD+1;
END;
PROCEDURE INITIN;
BEGIN
INPTR:=0;
ESCAPECHAR:=0;
WITH CURINPUT DO
BEGIN
STATE:=29;
BUFPTR:=1;
CURBUF:=BUFPTR+1;
LOC:=-1;
LVL:=0;
END;
PAGEWARNING:=OK;
NONEWCONTROLSEQ:=FALSE;
PAUSINGONERRORS:=TRUE;
DELETSALLOWED:=TRUE;
NOTNONSTOP:=TRUE;
END;
PROCEDURE POPTOKENLIST;
BEGIN
WITH CURINPUT DO
CASE RECOVERY.RHWORD
OF
0, 2:;
1: ALIGNSTATE:= 0;
3: DSLIST(RECOVERY.LHWORD);
OTHERS:
BEGIN
DELRCLINK(RECOVERY.LHWORD);
WHILE PARPTR>CURBUF DO
BEGIN PARPTR:=PARPTR-1;

DSLIST(PARSTACK[PARPTR]) END

END
END;

POPINPUT END;
PROCEDURE DUMPCONTEXT;
LABEL 0,
1;
VAR PTR: INTEGER;
T: INTEGER;
FIRSTPOS: INTEGER;
FIRST, LAST: INTEGER;
J: INTEGER;
BEGIN
INSTACK[INPTR]:=CURINPUT;
PTR:=INPTR;
WHILE TRUE DO BEGIN
WHILE INSTACK[PTR].STATE=0 DO

WITH INSTACK[PTR] DO
BEGIN
CASE RECOVERY.RHWORD
OF
0: BEGIN
PRINTLN(147);
FIRSTPOS:=12;
T:=RECOVERY.LHWORD
END;

1: BEGIN
PRINTLN(148);
FIRSTPOS:=9;
T:=RECOVERY.LHWORD
END;

2: BEGIN
PRINTLN(149);
FIRSTPOS:=9;
T:=RECOVERY.LHWORD
END;

3: IF LOC<>0
THEN
BEGIN PRINTLN(150);
FIRSTPOS:=20;
T:=RECOVERY.LHWORD
END
ELSE GOTO 1;
4: BEGIN
PRINTLN(-1);
FIRSTPOS:=1;
T:=MEM[RECOVERY.LHWORD].TWOHALVES.LHWORD
END;
OTHERS:
CONFUSION
END;

DUMPLIST(T,LOC);
IF TOKSPTR[0]>32 THEN
BEGIN PRINT(151);
FIRSTPOS:=FIRSTPOS+3;
FIRST:=TOKSPTR[0]-36
END
ELSE FIRST:=1;
FOR J:=FIRST TO TOKSPTR[0] DO
PRINT(TOKSTRING[0,J]);
PRINTLN(-1);
FOR J:=FIRST TO FIRSTPOS-1+TOKSPTR[0]
DO PRINT(32);
IF TOKSPTR[1]>32 THEN LAST:=29

ELSE LAST:=TOKSPTR[1];
FOR J:=1 TO LAST DO PRINT(TOKSTRING[1,J]);
IF LAST<>TOKSPTR[1] THEN PRINT(152);
1:
PTR:=PTR-1
END;

WITH INSTACK[PTR] DO
BEGIN
IF LOC<>-1
THEN BEGIN
PRINTLN(154);
PRINTINT(RECOVERY.RHWORD);
PRINT(155);
PRINTINT(RECOVERY.LHWORD);
PRINTLN(-1);
FIRSTPOS:=1
END
ELSE BEGIN PRINTLN(153);
FIRSTPOS:=5
END;
FOR J:=1 TO CURBUF-1 DO PRINT(BUFFER[J]);
PRINTLN(-1);
FOR J:=1 TO FIRSTPOS+CURBUF-1
DO PRINT(32);
FOR J:=CURBUF TO BUFPTR-1 DO PRINT(BUFFER[J]);
END;

IF(INSTACK[PTR].LOC<>-1) OR
(PTR=0)
THEN GOTO 0;
PTR:=PTR-1
END;
0:;

END;
PROCEDURE WHATSITAPPEND(P: INTEGER);
VAR Q: INTEGER;
BEGIN
IF ABS(MODE)<>167 THEN Q:=P
ELSE BEGIN Q:=GETNODE(2);
MEM[Q].TWOHALVES.BYTE2:=14;
MEM[Q+1].FOURBYTES.RHWORD:=P
END;
BEGIN
MEM[CURNODE].TWOHALVES.LHWORD:=Q;
CURNODE:=Q
END;

END;
PROCEDURE SENDIT(P: INTEGER);
VAR STREAM, TLIST: INTEGER;
TOKEN: INTEGER;
J: INTEGER;
BEGIN
IF MEM[P+1].TWOHALVES.LHWORD<>0 THEN
BEGIN
STREAM:=MEM[P+1].TWOHALVES.RHWORD
;
TLIST:=MEM[P+1].TWOHALVES.LHWORD
;

TOKEN:=GETAVAIL;
MEM[TOKEN].TWOHALVES.BYTE2:=2;
MEM[TOKEN].TWOHALVES.BYTE3:=126;
INSLIST(TOKEN);
INSRCLIST(TLIST);
DELRCLINK(TLIST);
TOKEN:=GETAVAIL;
MEM[TOKEN].TWOHALVES.BYTE2:=1;
MEM[TOKEN].TWOHALVES.BYTE3:=123;
MEM[P+1].TWOHALVES.LHWORD:=0;
CURCMD:=21;
HASHENTRY:=HASHSEND;
TLIST:=SCANTOKS;
DUMPLIST(MEM[TLIST].TWOHALVES
.LHWORD,0);
DSLIST(TLIST);
IF STREAM<0 THEN BEGIN PRINTLN(-1);
FOR J:=1 TO TOKSPTR[0] DO PRINT(TOKSTRING[0,J])

END
ELSE BEGIN FOR J:=1 TO TOKSPTR[0]
DO SENDCH(STREAM,TOKSTRING[0,J]);
SENDLN(STREAM)
END
END
END;
PROCEDURE INITEXT;
VAR D: INTEGER;
BEGIN
END;
PROCEDURE EXTOP;
BEGIN
PRINTLN(552);
ERROR;
END;
PROCEDURE DUMPEXT(P: INTEGER);
VAR J: INTEGER;
BEGIN
CASE MEM[P].TWOHALVES.BYTE3
OF
0: IF MEM[P+1].TWOHALVES.LHWORD
<>0 THEN
BEGIN 
DUMPLIST(MEM[MEM[P+1].TWOHALVES.LHWORD].TWOHALVES.LHWORD,0);
PRINT(553);
PRINTINT(MEM[P+1].TWOHALVES.RHWORD);
PRINT(123);
IF TOKSPTR[0]>30 THEN BEGIN FOR
J:=1 TO 30 DO PRINT(TOKSTRING[0,J]);
PRINT(554)
END
ELSE BEGIN FOR J:=1 TO TOKSPTR[0]
DO PRINT(TOKSTRING[0,J]);
PRINT(126)
END
END
ELSE PRINT(555);
OTHERS:
PRINT(556)
END;

END;
PROCEDURE DESTROYEXT(P: INTEGER);
BEGIN
CASE MEM[P].TWOHALVES.BYTE3
OF
0: BEGIN 
IF MEM[P+1].TWOHALVES.LHWORD<>0 THEN 
DELRCLINK(MEM[P+1].TWOHALVES.LHWORD);
FREENODE(P,2);
END;
OTHERS:
BEGIN PRINTLN(557);
ERROR;
QUIT
END
END
END;
FUNCTION COPYEXT(P: INTEGER):
INTEGER;
VAR Q, R: INTEGER;
BEGIN
CASE MEM[P].TWOHALVES.BYTE3
OF
0: BEGIN R:=GETNODE(2);
WITH MEM[R].TWOHALVES
DO BEGIN BYTE2:=3;
BYTE3:=0;
LHWORD:=0 END;
MEM[R+1]:=MEM[P+1];
Q:=MEM[R+1].TWOHALVES.LHWORD;

IF Q<>0 THEN MEM[Q].TWOHALVES
.RHWORD:=MEM[Q].TWOHALVES.RHWORD+1
END;
OTHERS:
BEGIN PRINTLN(558);
ERROR;
QUIT
END
END;

COPYEXT:=R
END;
PROCEDURE HPACKEXT(P: INTEGER);
BEGIN
END;
PROCEDURE VPACKEXT(P: INTEGER);
BEGIN
END;
PROCEDURE PAGEEXT(P: INTEGER);
BEGIN
END;
PROCEDURE JUSTEXT(P: INTEGER);
BEGIN
END;
PROCEDURE HOUTEXT(P: INTEGER;
VAR X,Y: REAL);
BEGIN
CASE MEM[P].TWOHALVES.BYTE3
OF
0: SENDIT(P);
OTHERS:
END
END;
PROCEDURE VOUTEXT(P: INTEGER;
VAR X,Y: REAL);
BEGIN
CASE MEM[P].TWOHALVES.BYTE3
OF
0: SENDIT(P);
OTHERS:
END
END;
PROCEDURE FINISHEXT;
VAR D: INTEGER;
BEGIN
FOR D:=0 TO 9 DO IF SENDSTARTED(D)
THEN CLOSE(D);
END;
PROCEDURE PAGEENDCHECK(L: INTEGER);
BEGIN
DELETSALLOWED:=FALSE;
IF CURLEV<>L THEN BEGIN
PRINTLN(156);
IF CURLEV>L THEN
BEGIN PRINT(43);
PRINTINT(CURLEV-L);
END
ELSE BEGIN PRINT(45);
PRINTINT(L-CURLEV);
END;
PRINT(157);
ERROR;
END;

IF PAGEWARNING=USEOF THEN BEGIN

MEM[Q].TWOHALVES.BYTE2:=TOKTYP;
IF TOKTYP=0 THEN
BEGIN MEM[Q].TWOHALVES.LHWORD:=GETAVAIL;
Q:=MEM[Q].TWOHALVES.LHWORD;
MEM[Q].TWOHALVES.RHWORD:=TOKVAL
END
ELSE MEM[Q].TWOHALVES.BYTE3:=TOKVAL;
PRINTLN(158);
PRINTLN(-1);
DUMPTOKENS(MEM[25003].TWOHALVES
.LHWORD) END;

IF PAGEWARNING<>OK THEN BEGIN

PRINTLN(159);
CASE PAGEWARNING OF
USEOF: PRINT(160);
DEFOF: PRINT(161);
OTHERS:
CONFUSION
END;

PRINT(ESCAPECHAR);
SHOWIDNAME(WARNINDEX);
PRINT(46);
ERROR;
END;

DELETSALLOWED:=TRUE
END;
PROCEDURE GETNEXT;
LABEL 0, 1, 2;
VAR LSAVE: INTEGER;
J: INTEGER;
BEGIN
0:
WITH CURINPUT DO
IF STATE<>0 THEN 2:
IF CURBUF<=BUFPTR THEN BEGIN

CURCHAR:=BUFFER[CURBUF];
CURCMD:=EQTB[CURCHAR+1137].INT
;
CURBUF:=CURBUF+1;

CASE STATE+ CURCMD OF
10, 24,
25, 38, 39:GOTO 2;
1, 15,
29:BEGIN
CONTROLSEQ;
WITH EQTB[HASHENTRY].FOURBYTES
DO
BEGIN CURCMD:=BYTE0;

IF(CURCMD=58) OR(CURCMD=54)
OR(CURCMD=55) THEN
BEGIN CURFONT:=BYTE2;
CURCHAR:=BYTE3
END
ELSE CURCHAR:=RHWORD
END;
STATE:=15
END;

11: BEGIN STATE:= 15;
CURCHAR:=32
END;

34: BEGIN CURBUF:=BUFPTR+1;
HASHENTRY:=HASHPAR;
WITH EQTB[HASHPAR].FOURBYTES
DO BEGIN CURCMD:=BYTE0;
CURCHAR:=RHWORD
END
END;

6: BEGIN STATE:=29;
CURBUF:=BUFPTR+1;
CURCMD:=10;
CURCHAR:=32
END;

20: BEGIN STATE:=29;
CURBUF:=BUFPTR+1;
GOTO 2
END;

2: ALIGNSTATE:=ALIGNSTATE+1;

16, 30: BEGIN STATE:=1;
ALIGNSTATE:=ALIGNSTATE+1
END;

3: ALIGNSTATE:=ALIGNSTATE-1;

17, 31: BEGIN STATE:=1;
ALIGNSTATE:=ALIGNSTATE-1
END;

18, 19,
21, 22, 23, 26,
27, 32, 33, 35,
40, 41:STATE:= 1;
OTHERS:
END
END
ELSE BEGIN BEGIN
IF(LOC<>-1)
THEN
BEGIN
INLN(LOC,BUFFER,BUFPTR,BRCHAR,EOFF);
CURBUF:=1;
IF EOFF THEN BEGIN LSAVE:=LVL;
PRINT(41);
RELEASE(LOC);
POPINPUT;
PAGEENDCHECK(LSAVE);
HASHENTRY:=HASHPAR;
WITH EQTB[HASHPAR].FOURBYTES
DO BEGIN CURCMD:=BYTE0;
CURCHAR:=RHWORD
END;
GOTO 1
END;

IF BRCHAR=0 THEN BEGIN
PRINTLN(163);
PRINTLN(164);
PRINTINT(RECOVERY.RHWORD);
PRINT(165);
PRINTINT(RECOVERY.LHWORD+1);
PRINT(58);
FOR J:=1 TO BUFPTR DO PRINT(BUFFER[J]);
RECOVERY.LHWORD:=RECOVERY.LHWORD-1
END;

IF ODD(EQTB[1408].TWOHALVES.RHWORD)

THEN TRACELINE(BUFFER,BUFPTR);
IF BRCHAR=12 THEN 
BEGIN 
RECOVERY.RHWORD:=RECOVERY.RHWORD+1;
PRINT(32);
PRINTINT(RECOVERY.RHWORD);
FORCEBUFFEROUT;
RECOVERY.LHWORD:=0;
PAGEENDCHECK(LVL);
END
ELSE RECOVERY.LHWORD:=RECOVERY.LHWORD+1
END
ELSE IF INPTR<>0 THEN
BEGIN POPINPUT;
GOTO 0
END
ELSE IF NOTNONSTOP THEN BEGIN

PRINTLN(42);
INLNTER(BUFFER,BUFPTR,BRCHAR);
CURBUF:=1;
WITH CURINPUT DO FOR J:=CURBUF
TO BUFPTR-1 DO OUTCHERR(BUFFER[J]);
OUTLNERR;
IF(ESCAPECHAR=0) AND(BUFFER[1]<>13)
THEN
BEGIN ESCAPECHAR:=BUFFER[1];
EQTB[ESCAPECHAR+1137].INT:=0;
END;

END
ELSE BEGIN
PRINTLN(162);
QUIT;
END;

END;

GOTO 2
END
ELSE IF LOC<>0 THEN BEGIN
BEGIN CURCMD:=MEM[LOC].TWOHALVES
.BYTE2;
CURCHAR:=MEM[LOC].TWOHALVES
.BYTE3;

LOC:=MEM[LOC].TWOHALVES.LHWORD
END;

CASE CURCMD OF
0:BEGIN
HASHENTRY:=MEM[LOC].TWOHALVES
.RHWORD;

WITH EQTB[HASHENTRY].FOURBYTES
DO
BEGIN CURCMD:=BYTE0;

IF(CURCMD=58) OR(CURCMD=54)
OR(CURCMD=55) THEN
BEGIN CURFONT:=BYTE2;
CURCHAR:=BYTE3
END
ELSE CURCHAR:=RHWORD
END;
LOC:=MEM[LOC].TWOHALVES.LHWORD
END;

9: BEGIN
PUSHINPUT;
WITH CURINPUT DO
BEGIN LOC:= PARSTACK[CURBUF+
CURCHAR];
RECOVERY.RHWORD:=0;
RECOVERY.LHWORD:=LOC;
GOTO 0 END
END;

1: ALIGNSTATE:=ALIGNSTATE+1;

2: ALIGNSTATE:=ALIGNSTATE-1;
OTHERS:
END
END
ELSE BEGIN POPTOKENLIST;
GOTO 0
END;

IF(ALIGNSTATE=0) AND((CURCMD=4)
OR(CURCMD=5))
THEN
BEGIN
ALIGNDELIM;
HASHENTRY:=-1;
GOTO 0
END;

1:
END;
PROCEDURE GETTOK;
BEGIN
HASHENTRY:=-1;

GETNEXT;
IF HASHENTRY>=0
THEN BEGIN CURTYP:=0;
CURVAL:=HASHENTRY
END
ELSE BEGIN CURTYP:=CURCMD;
CURVAL:=CURCHAR
END;

IF CURCMD=15
THEN
BEGIN
BACKINPUT;
PRINTLN(166);
ERROR;
CURCMD:=2
END
END;
PROCEDURE GETNCNEXT;
LABEL 0;
BEGIN
WHILE TRUE DO
BEGIN NONEWCONTROLSEQ:=TRUE;
GETNEXT;
NONEWCONTROLSEQ:=FALSE;

IF CURCMD=0 THEN
BEGIN
PRINTLN(167);
ERROR
END
ELSE IF CURCMD<>16
THEN GOTO 0
ELSE MACROCALL
END;
0:
END;
PROCEDURE GETNCTOK;
LABEL 0;
BEGIN
WHILE TRUE DO
BEGIN
HASHENTRY:=-1;
NONEWCONTROLSEQ:=TRUE;
GETNEXT;
NONEWCONTROLSEQ:=FALSE;

IF HASHENTRY<0 THEN BEGIN CURTYP:=CURCMD;
CURVAL:=CURCHAR;
GOTO 0
END
ELSE BEGIN CURTYP:=0;
CURVAL:=HASHENTRY;
IF CURCMD=0 THEN
BEGIN
PRINTLN(167);
ERROR
END
ELSE IF CURCMD<>16
THEN GOTO 0
ELSE MACROCALL
END
END;
0:
END;
FUNCTION SCANDIGIT: INTEGER;
FORWARD;
PROCEDURE SCANLB;
FORWARD;
PROCEDURE INSNUM(N: INTEGER);
FORWARD;
FUNCTION SCANTOKS;
LABEL 5,
0;

VAR CUR: INTEGER;
P,Q: INTEGER;
LISTHEAD: INTEGER;
CURHASH: INTEGER;
UNBAL: INTEGER;
BEGIN
CUR:=CURCMD;
CURHASH:=HASHENTRY;
PAGEWARNING:=DEFOF;
WARNINDEX:=HASHENTRY;
SCANLB;
LISTHEAD:=GETAVAIL;
MEM[LISTHEAD].TWOHALVES.RHWORD:=0;
P:=LISTHEAD;

UNBAL:=1;
WHILE TRUE DO BEGIN
IF((CUR=50) OR(CUR=21))
AND((CURVAL>=1137) OR(EQTB[CURVAL].FOURBYTES
.BYTE0<>21) OR(Q=LISTHEAD))
THEN BEGIN
5:
GETNCTOK;
PAGEWARNING:=DEFOF;
WARNINDEX:=CURHASH;
IF CUR=21 THEN
BEGIN
IF CURCMD=32 THEN
BEGIN
INSNUM(KOUNT[SCANDIGIT]);
GETTOK END
ELSE IF(CURCMD=49) AND NOT OUTPUTDORMANT
THEN
BEGIN
CASE CURCHAR OF
0: Q:=BOTMARK;
1: Q:=TOPMARK;
2: Q:=FIRSTMARK;
OTHERS:
CONFUSION
END;

IF Q<>0 THEN INSRCLIST(Q);

GOTO 5
END
END
END
ELSE GETTOK;
IF CURCMD=2 THEN
BEGIN UNBAL:=UNBAL-1;
IF UNBAL<=0 THEN GOTO 0
END

ELSE IF CURCMD=1 THEN UNBAL:=UNBAL+1
;

BEGIN
Q:=GETAVAIL;
MEM[P].TWOHALVES.LHWORD:=Q;
P:=Q;
MEM[P].TWOHALVES.BYTE2:=CURTYP;
IF CURTYP=0 THEN BEGIN Q:=GETAVAIL;
MEM[P].TWOHALVES.LHWORD:=Q;
P:=Q;
MEM[P].TWOHALVES.RHWORD:=CURVAL
END
ELSE MEM[P].TWOHALVES.BYTE3:=CURVAL
END
END;
0:;

PAGEWARNING:=OK;
IF CUR=22 THEN
BEGIN
Q:=GETAVAIL;
MEM[P].TWOHALVES.LHWORD:=Q;
P:=Q;
MEM[P].TWOHALVES.BYTE2:=CURTYP;
MEM[P].TWOHALVES.BYTE3:=CURVAL;

GETNCTOK;
IF CURCMD<>10 THEN BACKINPUT
END;
MEM[Q].TWOHALVES.LHWORD:=0;
SCANTOKS:=LISTHEAD;
END;
PROCEDURE MACRODEF(GDEF: INTEGER);
LABEL 1;
VAR DEFPLACE: INTEGER;
TOKTYP,TOKVAL: INTEGER;
P,Q:INTEGER;
LISTHEAD: INTEGER;
NPARS: INTEGER;
UNBAL: INTEGER;
T: INTEGER;
BEGIN
GETTOK;
DEFPLACE:=HASHENTRY;

IF DEFPLACE<0
THEN BEGIN
BACKINPUT;
PRINTLN(168);
ERROR
END
ELSE BEGIN
LISTHEAD:= GETAVAIL;
MEM[LISTHEAD].TWOHALVES.RHWORD:=0;
P:=GETAVAIL;
Q:=GETAVAIL;
MEM[P].TWOHALVES.BYTE2:=0;
MEM[Q].TWOHALVES.RHWORD:=DEFPLACE;
MEM[P].TWOHALVES.LHWORD:=Q;
MEM[LISTHEAD].TWOHALVES.LHWORD:=P;
IF GDEF=2
THEN BEGIN P:=Q;
CURCMD:=21;
Q:=SCANTOKS;
MEM[Q].TWOHALVES.BYTE2:=14;
MEM[Q].TWOHALVES.BYTE3:=1;
MEM[P].TWOHALVES.LHWORD:=Q;
END
ELSE BEGIN
NPARS:=0;
REPEAT
GETTOK;
IF CURCMD<>6 THEN BEGIN TOKTYP:=CURTYP;
TOKVAL:=CURVAL END
ELSE BEGIN GETTOK;
NPARS:=NPARS+1;
IF(CURCHAR-48<>NPARS) OR(CURCMD<>12)

THEN BEGIN
BACKINPUT;
PRINTLN(170);
ERROR
END;

IF(NPARS>26)
THEN OVERFLOW(169,26);
TOKTYP:=14;
TOKVAL:=0 END;

P:=Q;
Q:=GETAVAIL;
MEM[P].TWOHALVES.LHWORD:=Q;
MEM[Q].TWOHALVES.BYTE2:=TOKTYP;
IF TOKTYP=0 THEN BEGIN P:=Q;
Q:=GETAVAIL;
MEM[Q].TWOHALVES.RHWORD:=TOKVAL;
MEM[P].TWOHALVES.LHWORD:=Q;
END
ELSE MEM[Q].TWOHALVES.BYTE3:=TOKVAL
UNTIL(CURCMD=1) OR(CURCMD=2);
MEM[Q].TWOHALVES.BYTE2:=14;
MEM[Q].TWOHALVES.BYTE3:=1;
IF CURCMD=2
THEN
BEGIN
BEGIN
ALIGNSTATE:=ALIGNSTATE+1;
PRINTLN(171);
ERROR
END;

GOTO 1 END;

PAGEWARNING:=DEFOF;
WARNINDEX:=DEFPLACE;
UNBAL:=1;
WHILE TRUE DO BEGIN
GETTOK;
IF CURCMD=2 THEN
BEGIN UNBAL:=UNBAL-1;
IF UNBAL<=0 THEN GOTO 1
END
ELSE IF CURCMD=1 THEN UNBAL:=UNBAL+1
;
IF CURCMD<>6 THEN BEGIN TOKTYP:=CURTYP;
TOKVAL:=CURVAL END
ELSE BEGIN GETTOK;
IF CURCMD<>6 THEN BEGIN
IF(CURCHAR>(48+NPARS)) OR(CURCHAR<49)
THEN
BEGIN
BEGIN
BACKINPUT;
PRINTLN(172);
PRINT(ESCAPECHAR);
SHOWIDNAME(DEFPLACE);
PRINT(46);
ERROR
END;

TOKTYP:=CURTYP;
TOKVAL:=CURVAL END
ELSE BEGIN TOKTYP:=9;
TOKVAL:=CURCHAR-49
END
END
ELSE BEGIN TOKTYP:=CURTYP;
TOKVAL:=CURVAL
END
END;

P:=Q;
Q:=GETAVAIL;
MEM[P].TWOHALVES.LHWORD:=Q;
MEM[Q].TWOHALVES.BYTE2:=TOKTYP;
IF TOKTYP=0 THEN BEGIN P:=Q;
Q:=GETAVAIL;
MEM[Q].TWOHALVES.RHWORD:=TOKVAL;
MEM[P].TWOHALVES.LHWORD:=Q;
END
ELSE MEM[Q].TWOHALVES.BYTE3:=TOKVAL
END;

1:
MEM[Q].TWOHALVES.LHWORD:=0;
PAGEWARNING:=OK END;

IF GDEF<>0
THEN
BEGIN T:=CURLEV;
CURLEV:=1;
END;
EQDEFINE(DEFPLACE,16,LISTHEAD);
IF GDEF<>0
THEN CURLEV:=T;
GETNCTOK;
IF CURCMD<>10 THEN BACKINPUT
END;
END;
PROCEDURE MACROCALL;
LABEL 0,
1;
VAR MACLIST: INTEGER;
DEFPLACE: INTEGER;
R: INTEGER;
NPARS: INTEGER;
FIRSTERROR: BOOLEAN;
TTYP,TVAL: INTEGER;
NGRPS: INTEGER;
PREVCMD: INTEGER;
P: INTEGER;
UNBAL: INTEGER;
J: INTEGER;
BEGIN
DEFPLACE:=HASHENTRY;
MACLIST:=CURCHAR;
PAGEWARNING:=USEOF;
WARNINDEX:=DEFPLACE;
R:=MEM[MACLIST].TWOHALVES.LHWORD;
IF(EQTB[1408].INT<>4194784)

THEN IF ODD(EQTB[1408].TWOHALVES.LHWORD)

THEN
BEGIN PRINTLN(-1);
DUMPTOKENS(R) END;

R:=MEM[MEM[R].TWOHALVES.LHWORD].TWOHALVES.LHWORD;

NPARS:=0;
FIRSTERROR:=TRUE;
TTYP:=MEM[R].TWOHALVES.BYTE2;

IF TTYP=0 THEN
BEGIN R:=MEM[R].TWOHALVES.LHWORD;
TVAL:=MEM[R].TWOHALVES.RHWORD
END
ELSE TVAL:=MEM[R].TWOHALVES.BYTE3;
WHILE(TTYP<>14) OR(TVAL<>1)

DO
BEGIN
R:=MEM[R].TWOHALVES.LHWORD;
IF(TTYP<>14) OR(TVAL<>0)

THEN BEGIN
GETTOK;
IF((TTYP<>CURTYP) OR(TVAL<>CURVAL))
AND FIRSTERROR THEN
BEGIN
FIRSTERROR:=FALSE;
PRINTLN(175);
PRINT(ESCAPECHAR);
SHOWIDNAME(DEFPLACE);
PRINT(176);
ERROR
END
END
ELSE BEGIN
TTYP:=MEM[R].TWOHALVES.BYTE2;

IF TTYP=0 THEN
BEGIN R:=MEM[R].TWOHALVES.LHWORD;
TVAL:=MEM[R].TWOHALVES.RHWORD
END
ELSE TVAL:=MEM[R].TWOHALVES.BYTE3;
IF(TTYP=14)
THEN
TTYP:=250
ELSE R:=MEM[R].TWOHALVES
.LHWORD;
Q:=25003;
MEM[25003].TWOHALVES.LHWORD:=0;
NGRPS:=0;
GETTOK;
TOKTYP:=83;
TOKVAL:=0;
WHILE(CURTYP<>TTYP) OR(CURVAL<>TVAL)

DO
BEGIN
WHILE CURCMD=2 DO
BEGIN
ALIGNSTATE:=ALIGNSTATE+1;

PRINTLN(173);
PRINT(ESCAPECHAR);
SHOWIDNAME(DEFPLACE);
PRINT(174);
ERROR;
GETTOK END;

BEGIN
P:=Q;
Q:=GETAVAIL;
WITH MEM[P].TWOHALVES
DO BEGIN BYTE2:=TOKTYP;
LHWORD:=Q END;
IF TOKTYP=0 THEN
BEGIN P:=Q;
Q:=GETAVAIL;
WITH MEM[P].TWOHALVES
DO BEGIN LHWORD:=Q;
RHWORD:=TOKVAL END
END
ELSE MEM[P].TWOHALVES.BYTE3:=TOKVAL;
TOKTYP:=CURTYP;
TOKVAL:=CURVAL
END;

IF CURCMD=1 THEN
BEGIN
UNBAL:=1;
WHILE TRUE DO BEGIN
GETTOK;
BEGIN
P:=Q;
Q:=GETAVAIL;
WITH MEM[P].TWOHALVES
DO BEGIN BYTE2:=TOKTYP;
LHWORD:=Q END;
IF TOKTYP=0 THEN
BEGIN P:=Q;
Q:=GETAVAIL;
WITH MEM[P].TWOHALVES
DO BEGIN LHWORD:=Q;
RHWORD:=TOKVAL END
END
ELSE MEM[P].TWOHALVES.BYTE3:=TOKVAL;
TOKTYP:=CURTYP;
TOKVAL:=CURVAL
END;

IF CURCMD=2 THEN
BEGIN UNBAL:=UNBAL-1;
IF UNBAL<=0 THEN GOTO 0
END

ELSE IF CURCMD=1 THEN UNBAL:=UNBAL+1

END;
0:
END;

NGRPS:=NGRPS+1;
PREVCMD:=CURCMD;
IF TTYP=250
THEN GOTO 1
ELSE GETTOK
END;
1:;

IF(NGRPS=1) AND(PREVCMD=2)
THEN
BEGIN
MEM[P].TWOHALVES.LHWORD:=0;
FREEAVAIL(Q);
PSTACK[NPARS]:=MEM[MEM[25003].TWOHALVES
.LHWORD].TWOHALVES.LHWORD;
FREEAVAIL(MEM[25003].TWOHALVES
.LHWORD) END
ELSE BEGIN
MEM[Q].TWOHALVES.BYTE2:=TOKTYP;
IF TOKTYP=0 THEN
BEGIN P:=Q;
Q:=GETAVAIL;
MEM[Q].TWOHALVES.RHWORD:=TOKVAL;
MEM[P].TWOHALVES.LHWORD:=Q
END
ELSE MEM[Q].TWOHALVES.BYTE3:=TOKVAL;
PSTACK[NPARS]:=MEM[25003].TWOHALVES
.LHWORD;
END;

IF(EQTB[1408].INT<>4194784)
THEN IF ODD(EQTB[1408].TWOHALVES.LHWORD)

THEN
BEGIN PRINTLN(35);
PRINT(NPARS+49);
PRINT(95);
DUMPTOKENS(PSTACK[NPARS])
END;

NPARS:=NPARS+1
END;

TTYP:=MEM[R].TWOHALVES.BYTE2;

IF TTYP=0 THEN
BEGIN R:=MEM[R].TWOHALVES.LHWORD;
TVAL:=MEM[R].TWOHALVES.RHWORD
END
ELSE TVAL:=MEM[R].TWOHALVES.BYTE3
END;

PAGEWARNING:=OK;
WHILE(CURINPUT.STATE=0) AND(CURINPUT.LOC=0)
DO POPTOKENLIST;
IF(PARPTR+NPARS)>26 THEN OVERFLOW(177,26);
FOR J:=0 TO NPARS-1 DO PARSTACK[PARPTR+J]:=PSTACK[J];
PUSHINPUT;
WITH CURINPUT DO
BEGIN
LOC:=MEM[R].TWOHALVES.LHWORD;
STATE:=0;
RECOVERY.RHWORD:=4;
RECOVERY.LHWORD:=MACLIST;
CURBUF:=PARPTR;
PARPTR:=PARPTR+NPARS END;

MEM[MACLIST].TWOHALVES.RHWORD:=MEM[MACLIST].TWOHALVES.RHWORD+1;

END;
PROCEDURE INITMATHCODES;
BEGIN
WITH EQTB[0+1265].FOURBYTES
DO BEGIN BYTE2:=2+(2*8);
BYTE3:=1 END;
WITH EQTB[1+1265].FOURBYTES
DO BEGIN BYTE2:=2+(3*8);
BYTE3:=35 END;
WITH EQTB[2+1265].FOURBYTES
DO BEGIN BYTE2:=1;
BYTE3:=11 END;
WITH EQTB[3+1265].FOURBYTES
DO BEGIN BYTE2:=1;
BYTE3:=12 END;
WITH EQTB[4+1265].FOURBYTES
DO BEGIN BYTE2:=2+(2*8);
BYTE3:=94 END;
WITH EQTB[5+1265].FOURBYTES
DO BEGIN BYTE2:=2;
BYTE3:=58 END;
WITH EQTB[6+1265].FOURBYTES
DO BEGIN BYTE2:=1;
BYTE3:=15 END;
WITH EQTB[7+1265].FOURBYTES
DO BEGIN BYTE2:=1;
BYTE3:=25 END;
WITH EQTB[8+1265].FOURBYTES
DO BEGIN BYTE2:=1;
BYTE3:=21 END;
WITH EQTB[9+1265].FOURBYTES
DO BEGIN BYTE2:=1;
BYTE3:=13 END;
WITH EQTB[10+1265].FOURBYTES
DO BEGIN BYTE2:=1;
BYTE3:=14 END;
WITH EQTB[11+1265].FOURBYTES
DO BEGIN BYTE2:=2+(1*8);
BYTE3:=115 END;
WITH EQTB[12+1265].FOURBYTES
DO BEGIN BYTE2:=2+(2*8);
BYTE3:=6 END;
WITH EQTB[13+1265].FOURBYTES
DO BEGIN BYTE2:=2+(2*8);
BYTE3:=8 END;
WITH EQTB[14+1265].FOURBYTES
DO BEGIN BYTE2:=2;
BYTE3:=49 END;
WITH EQTB[15+1265].FOURBYTES
DO BEGIN BYTE2:=1;
BYTE3:=37 END;
WITH EQTB[16+1265].FOURBYTES
DO BEGIN BYTE2:=2+(3*8);
BYTE3:=26 END;
WITH EQTB[17+1265].FOURBYTES
DO BEGIN BYTE2:=2+(3*8);
BYTE3:=27 END;
WITH EQTB[18+1265].FOURBYTES
DO BEGIN BYTE2:=2+(2*8);
BYTE3:=92 END;
WITH EQTB[19+1265].FOURBYTES
DO BEGIN BYTE2:=2+(2*8);
BYTE3:=91 END;
WITH EQTB[20+1265].FOURBYTES
DO BEGIN BYTE2:=2;
BYTE3:=56 END;
WITH EQTB[21+1265].FOURBYTES
DO BEGIN BYTE2:=2;
BYTE3:=57 END;
WITH EQTB[22+1265].FOURBYTES
DO BEGIN BYTE2:=2+(2*8);
BYTE3:=10 END;
WITH EQTB[23+1265].FOURBYTES
DO BEGIN BYTE2:=2+(3*8);
BYTE3:=36 END;
WITH EQTB[24+1265].FOURBYTES
DO BEGIN BYTE2:=2;
BYTE3:=53 END;
WITH EQTB[25+1265].FOURBYTES
DO BEGIN BYTE2:=2+(3*8);
BYTE3:=33 END;
WITH EQTB[26+1265].FOURBYTES
DO BEGIN BYTE2:=2+(3*8);
BYTE3:=24 END;
WITH EQTB[27+1265].FOURBYTES
DO BEGIN BYTE2:=2+(3*8);
BYTE3:=28 END;
WITH EQTB[28+1265].FOURBYTES
DO BEGIN BYTE2:=2+(3*8);
BYTE3:=20 END;
WITH EQTB[29+1265].FOURBYTES
DO BEGIN BYTE2:=2+(3*8);
BYTE3:=21 END;
WITH EQTB[30+1265].FOURBYTES
DO BEGIN BYTE2:=2+(3*8);
BYTE3:=17 END;
WITH EQTB[31+1265].FOURBYTES
DO BEGIN BYTE2:=2+(2*8);
BYTE3:=95 END;
WITH EQTB[32+1265].FOURBYTES
DO BEGIN BYTE2:=2;
BYTE3:=51 END;
WITH EQTB[33+1265].FOURBYTES
DO BEGIN BYTE2:=0+(5*8);
BYTE3:=33 END;
WITH EQTB[34+1265].FOURBYTES
DO BEGIN BYTE2:=2;
BYTE3:=97 END;
WITH EQTB[35+1265].FOURBYTES
DO BEGIN BYTE2:=2;
BYTE3:=113 END;
WITH EQTB[36+1265].FOURBYTES
DO BEGIN BYTE2:=2;
BYTE3:=127 END;
WITH EQTB[37+1265].FOURBYTES
DO BEGIN BYTE2:=0;
BYTE3:=37 END;
WITH EQTB[38+1265].FOURBYTES
DO BEGIN BYTE2:=0;
BYTE3:=38 END;
WITH EQTB[39+1265].FOURBYTES
DO BEGIN BYTE2:=0+(5*8);
BYTE3:=39 END;
WITH EQTB[40+1265].FOURBYTES
DO BEGIN BYTE2:=0+(4*8);
BYTE3:=40 END;
WITH EQTB[41+1265].FOURBYTES
DO BEGIN BYTE2:=0+(5*8);
BYTE3:=41 END;
WITH EQTB[42+1265].FOURBYTES
DO BEGIN BYTE2:=0;
BYTE3:=42 END;
WITH EQTB[43+1265].FOURBYTES
DO BEGIN BYTE2:=0+(2*8);
BYTE3:=43 END;
WITH EQTB[44+1265].FOURBYTES
DO BEGIN BYTE2:=0+(6*8);
BYTE3:=44 END;
WITH EQTB[45+1265].FOURBYTES
DO BEGIN BYTE2:=2+(2*8);
BYTE3:=0 END;
WITH EQTB[46+1265].FOURBYTES
DO BEGIN BYTE2:=0;
BYTE3:=46 END;
WITH EQTB[47+1265].FOURBYTES
DO BEGIN BYTE2:=0;
BYTE3:=47 END;
WITH EQTB[48+1265].FOURBYTES
DO BEGIN BYTE2:=0;
BYTE3:=48 END;
WITH EQTB[49+1265].FOURBYTES
DO BEGIN BYTE2:=0;
BYTE3:=49 END;
WITH EQTB[50+1265].FOURBYTES
DO BEGIN BYTE2:=0;
BYTE3:=50 END;
WITH EQTB[51+1265].FOURBYTES
DO BEGIN BYTE2:=0;
BYTE3:=51 END;
WITH EQTB[52+1265].FOURBYTES
DO BEGIN BYTE2:=0;
BYTE3:=52 END;
WITH EQTB[53+1265].FOURBYTES
DO BEGIN BYTE2:=0;
BYTE3:=53 END;
WITH EQTB[54+1265].FOURBYTES
DO BEGIN BYTE2:=0;
BYTE3:=54 END;
WITH EQTB[55+1265].FOURBYTES
DO BEGIN BYTE2:=0;
BYTE3:=55 END;
WITH EQTB[56+1265].FOURBYTES
DO BEGIN BYTE2:=0;
BYTE3:=56 END;
WITH EQTB[57+1265].FOURBYTES
DO BEGIN BYTE2:=0;
BYTE3:=57 END;
WITH EQTB[58+1265].FOURBYTES
DO BEGIN BYTE2:=0;
BYTE3:=58 END;
WITH EQTB[59+1265].FOURBYTES
DO BEGIN BYTE2:=0+(6*8);
BYTE3:=59 END;
WITH EQTB[60+1265].FOURBYTES
DO BEGIN BYTE2:=0+(3*8);
BYTE3:=60 END;
WITH EQTB[61+1265].FOURBYTES
DO BEGIN BYTE2:=0+(3*8);
BYTE3:=61 END;
WITH EQTB[62+1265].FOURBYTES
DO BEGIN BYTE2:=0+(3*8);
BYTE3:=62 END;
WITH EQTB[63+1265].FOURBYTES
DO BEGIN BYTE2:=0+(5*8);
BYTE3:=63 END;
WITH EQTB[64+1265].FOURBYTES
DO BEGIN BYTE2:=2;
BYTE3:=124 END;
WITH EQTB[65+1265].FOURBYTES
DO BEGIN BYTE2:=1;
BYTE3:=65 END;
WITH EQTB[66+1265].FOURBYTES
DO BEGIN BYTE2:=1;
BYTE3:=66 END;
WITH EQTB[67+1265].FOURBYTES
DO BEGIN BYTE2:=1;
BYTE3:=67 END;
WITH EQTB[68+1265].FOURBYTES
DO BEGIN BYTE2:=1;
BYTE3:=68 END;
WITH EQTB[69+1265].FOURBYTES
DO BEGIN BYTE2:=1;
BYTE3:=69 END;
WITH EQTB[70+1265].FOURBYTES
DO BEGIN BYTE2:=1;
BYTE3:=70 END;
WITH EQTB[71+1265].FOURBYTES
DO BEGIN BYTE2:=1;
BYTE3:=71 END;
WITH EQTB[72+1265].FOURBYTES
DO BEGIN BYTE2:=1;
BYTE3:=72 END;
WITH EQTB[73+1265].FOURBYTES
DO BEGIN BYTE2:=1;
BYTE3:=73 END;
WITH EQTB[74+1265].FOURBYTES
DO BEGIN BYTE2:=1;
BYTE3:=74 END;
WITH EQTB[75+1265].FOURBYTES
DO BEGIN BYTE2:=1;
BYTE3:=75 END;
WITH EQTB[76+1265].FOURBYTES
DO BEGIN BYTE2:=1;
BYTE3:=76 END;
WITH EQTB[77+1265].FOURBYTES
DO BEGIN BYTE2:=1;
BYTE3:=77 END;
WITH EQTB[78+1265].FOURBYTES
DO BEGIN BYTE2:=1;
BYTE3:=78 END;
WITH EQTB[79+1265].FOURBYTES
DO BEGIN BYTE2:=1;
BYTE3:=79 END;
WITH EQTB[80+1265].FOURBYTES
DO BEGIN BYTE2:=1;
BYTE3:=80 END;
WITH EQTB[81+1265].FOURBYTES
DO BEGIN BYTE2:=1;
BYTE3:=81 END;
WITH EQTB[82+1265].FOURBYTES
DO BEGIN BYTE2:=1;
BYTE3:=82 END;
WITH EQTB[83+1265].FOURBYTES
DO BEGIN BYTE2:=1;
BYTE3:=83 END;
WITH EQTB[84+1265].FOURBYTES
DO BEGIN BYTE2:=1;
BYTE3:=84 END;
WITH EQTB[85+1265].FOURBYTES
DO BEGIN BYTE2:=1;
BYTE3:=85 END;
WITH EQTB[86+1265].FOURBYTES
DO BEGIN BYTE2:=1;
BYTE3:=86 END;
WITH EQTB[87+1265].FOURBYTES
DO BEGIN BYTE2:=1;
BYTE3:=87 END;
WITH EQTB[88+1265].FOURBYTES
DO BEGIN BYTE2:=1;
BYTE3:=88 END;
WITH EQTB[89+1265].FOURBYTES
DO BEGIN BYTE2:=1;
BYTE3:=89 END;
WITH EQTB[90+1265].FOURBYTES
DO BEGIN BYTE2:=1;
BYTE3:=90 END;
WITH EQTB[91+1265].FOURBYTES
DO BEGIN BYTE2:=0+(4*8);
BYTE3:=91 END;
WITH EQTB[92+1265].FOURBYTES
DO BEGIN BYTE2:=2+(2*8);
BYTE3:=4 END;
WITH EQTB[93+1265].FOURBYTES
DO BEGIN BYTE2:=0+(5*8);
BYTE3:=93 END;
WITH EQTB[94+1265].FOURBYTES
DO BEGIN BYTE2:=2+(3*8);
BYTE3:=34 END;
WITH EQTB[95+1265].FOURBYTES
DO BEGIN BYTE2:=2+(3*8);
BYTE3:=32 END;
WITH EQTB[96+1265].FOURBYTES
DO BEGIN BYTE2:=0+(4*8);
BYTE3:=96 END;
WITH EQTB[97+1265].FOURBYTES
DO BEGIN BYTE2:=1;
BYTE3:=97 END;
WITH EQTB[98+1265].FOURBYTES
DO BEGIN BYTE2:=1;
BYTE3:=98 END;
WITH EQTB[99+1265].FOURBYTES
DO BEGIN BYTE2:=1;
BYTE3:=99 END;
WITH EQTB[100+1265].FOURBYTES

DO BEGIN BYTE2:=1;
BYTE3:=100 END;
WITH EQTB[101+1265].FOURBYTES

DO BEGIN BYTE2:=1;
BYTE3:=101 END;
WITH EQTB[102+1265].FOURBYTES

DO BEGIN BYTE2:=1;
BYTE3:=102 END;
WITH EQTB[103+1265].FOURBYTES

DO BEGIN BYTE2:=1;
BYTE3:=103 END;
WITH EQTB[104+1265].FOURBYTES

DO BEGIN BYTE2:=1;
BYTE3:=104 END;
WITH EQTB[105+1265].FOURBYTES

DO BEGIN BYTE2:=1;
BYTE3:=105 END;
WITH EQTB[106+1265].FOURBYTES

DO BEGIN BYTE2:=1;
BYTE3:=106 END;
WITH EQTB[107+1265].FOURBYTES

DO BEGIN BYTE2:=1;
BYTE3:=107 END;
WITH EQTB[108+1265].FOURBYTES

DO BEGIN BYTE2:=1;
BYTE3:=108 END;
WITH EQTB[109+1265].FOURBYTES

DO BEGIN BYTE2:=1;
BYTE3:=109 END;
WITH EQTB[110+1265].FOURBYTES

DO BEGIN BYTE2:=1;
BYTE3:=110 END;
WITH EQTB[111+1265].FOURBYTES

DO BEGIN BYTE2:=1;
BYTE3:=111 END;
WITH EQTB[112+1265].FOURBYTES

DO BEGIN BYTE2:=1;
BYTE3:=112 END;
WITH EQTB[113+1265].FOURBYTES

DO BEGIN BYTE2:=1;
BYTE3:=113 END;
WITH EQTB[114+1265].FOURBYTES

DO BEGIN BYTE2:=1;
BYTE3:=114 END;
WITH EQTB[115+1265].FOURBYTES

DO BEGIN BYTE2:=1;
BYTE3:=115 END;
WITH EQTB[116+1265].FOURBYTES

DO BEGIN BYTE2:=1;
BYTE3:=116 END;
WITH EQTB[117+1265].FOURBYTES

DO BEGIN BYTE2:=1;
BYTE3:=117 END;
WITH EQTB[118+1265].FOURBYTES

DO BEGIN BYTE2:=1;
BYTE3:=118 END;
WITH EQTB[119+1265].FOURBYTES

DO BEGIN BYTE2:=1;
BYTE3:=119 END;
WITH EQTB[120+1265].FOURBYTES

DO BEGIN BYTE2:=1;
BYTE3:=120 END;
WITH EQTB[121+1265].FOURBYTES

DO BEGIN BYTE2:=1;
BYTE3:=121 END;
WITH EQTB[122+1265].FOURBYTES

DO BEGIN BYTE2:=1;
BYTE3:=122 END;
WITH EQTB[123+1265].FOURBYTES

DO BEGIN BYTE2:=2+(4*8);
BYTE3:=102 END;
WITH EQTB[124+1265].FOURBYTES

DO BEGIN BYTE2:=2;
BYTE3:=106 END;
WITH EQTB[125+1265].FOURBYTES

DO BEGIN BYTE2:=2+(2*8);
BYTE3:=5 END;
WITH EQTB[126+1265].FOURBYTES

DO BEGIN BYTE2:=2+(5*8);
BYTE3:=103 END;
WITH EQTB[127+1265].FOURBYTES

DO BEGIN BYTE2:=0+(2*8);
BYTE3:=15 END;
END;
FUNCTION SCANFILENAME(FYL: INTEGER):
INTEGER;
LABEL 1;
VAR F: INTEGER;
BEGIN
F:=INITFILENAME(FYL);
GETNCTOK;
WHILE TRUE DO
CASE APPENDTONAME(CURCMD,CURCHAR)
OF
0: GOTO 1;
1: BEGIN F:=(-(F+1));
GOTO 1
END;
2: BEGIN BACKINPUT;
ERROR;
GETNCTOK END;
3: GETNCTOK;
OTHERS:
CONFUSION
END;

1:
SCANFILENAME:=F;
END;
PROCEDURE INPUTFILE;
VAR F: INTEGER;
PAGE: INTEGER;
BEGIN
F:=SCANFILENAME(-2);
IF(F<0)
THEN
BEGIN
BEGIN
PRINTLN(178);
PRINTFILENAME((((65+(9))+((-(F+1))))));
ERROR END;

F:=SCANFILENAME(-2) END;

IF NOT(F<0)
THEN
BEGIN
PUSHINPUT;
PRINT(179);
PRINTFILENAME(((65+(9))+(F)));
WITH CURINPUT DO
BEGIN STATE:=29;
LOC:=F;
LVL:=CURLEV;
END;

WITH CURINPUT DO
IF NOT GETFIRSTLINE(LOC,BUFFER,BUFPTR,BRCHAR,EOFF,PAGE)
THEN
BEGIN
PRINT(41);
RELEASE(F);
POPINPUT END
ELSE BEGIN CURBUF:=1;
RECOVERY.RHWORD:=PAGE;
RECOVERY.LHWORD:=1;
IF(EQTB[1408].INT<>4194784)
THEN IF ODD(EQTB[1408].TWOHALVES.RHWORD)

THEN TRACELINE(BUFFER,BUFPTR);
IF NOOUTPUTYET THEN BEGIN
DECLAREOFIL(((65+(9))+(F)));
NOOUTPUTYET:=FALSE
END
END
END;

END;
PROCEDURE OPENDIGIT(D: INTEGER);
VAR F: INTEGER;
J: INTEGER;
BEGIN
F:=SCANFILENAME((65+D));
END;
PROCEDURE DEFINEFONT(FYL: INTEGER);
FORWARD;
PROCEDURE BACKINPUT;
VAR P: INTEGER;
BEGIN
P:=GETAVAIL;
MEM[P].TWOHALVES.BYTE2:=CURTYP;
IF CURTYP=0 THEN BEGIN MEM[P].TWOHALVES
.LHWORD:=GETAVAIL;
MEM[MEM[P].TWOHALVES.LHWORD].TWOHALVES.RHWORD:=CURVAL END
ELSE MEM[P].TWOHALVES.BYTE3:=CURVAL;

IF CURCMD=1 THEN ALIGNSTATE:=ALIGNSTATE-1

ELSE IF CURCMD=2 THEN ALIGNSTATE:=ALIGNSTATE+1
;
INSLIST(P);

END;
FUNCTION SCANDIGIT;
VAR D: INTEGER;
BEGIN
GETNCTOK;
D:=CURCHAR;
IF(CURTYP<>12)
OR(NOT((CURVAL>=48) AND(CURVAL<=57))
)
THEN BEGIN
BACKINPUT;
PRINTLN(180);
ERROR;
D:=48
END;

GETNCTOK;
IF CURCMD<>10 THEN BACKINPUT;

SCANDIGIT:=D
END;
PROCEDURE SCANLB;
BEGIN
REPEAT GETNCTOK UNTIL CURCMD<>10
;
IF CURCMD<>1
THEN
BEGIN
BACKINPUT;
BEGIN
ALIGNSTATE:=ALIGNSTATE+1;
PRINTLN(171);
ERROR
END;
END;
END;
FUNCTION SCANSTRING;
LABEL 1;
VAR S: ASCIISTRING;
J: INTEGER;
C: ASCIICODE;
Q: INTEGER;
P: INTEGER;
HEAD: INTEGER;
I: INTEGER;
BEGIN
SCANSTRING:=FALSE;
PRODUCESTRING(PARTICLE,S);
J:=0;
C:=S[0];
WHILE C<>0 DO
BEGIN
GETNCTOK;
BEGIN
IF(C>=65) AND(C<=90) THEN
C:=C+32
END;
IF(CURTYP<>11) OR((CURVAL<>C)
AND(CURVAL<>C-32))
THEN
BEGIN
Q:=GETAVAIL;
HEAD:=Q;
FOR I:=0 TO J-1 DO
BEGIN
P:=Q;
Q:=GETAVAIL;
MEM[P].TWOHALVES.BYTE2:=11;
MEM[P].TWOHALVES.BYTE3:=S[I];
MEM[P].TWOHALVES.LHWORD:=Q;
END;
MEM[Q].TWOHALVES.BYTE2:=CURTYP;
IF CURTYP=0 THEN BEGIN P:=Q;
Q:=GETAVAIL;
MEM[P].TWOHALVES.LHWORD:=Q;
MEM[Q].TWOHALVES.RHWORD:=CURVAL END
ELSE MEM[Q].TWOHALVES.BYTE3:=CURVAL;
MEM[Q].TWOHALVES.LHWORD:=0;

IF CURCMD=1 THEN ALIGNSTATE:=ALIGNSTATE-1

ELSE IF CURCMD=2 THEN ALIGNSTATE:=ALIGNSTATE+1
;
INSLIST(HEAD);
SCANSTRING:=FALSE;
GOTO 1
END;

S[J]:=CURVAL;
J:=J+1;

C:=S[J]
END;
SCANSTRING:=TRUE;
1:
END;
FUNCTION SCANNUMBER: INTEGER;
VAR N: INTEGER;
RADIX: INTEGER;
M: INTEGER;
BEGIN
N:=0;
NBRLENGTH:=0;
NBRSIGN:=43;
RADIX:=10;

REPEAT GETNCTOK UNTIL CURCMD<>10
;
IF(CURTYP=12)
AND((CURVAL=43) OR(CURVAL=45))
THEN
BEGIN
NBRSIGN:=CURCHAR;
REPEAT GETNCTOK UNTIL CURCMD<>10

END;

IF(CURCMD=12) AND(CURVAL=39)
THEN
BEGIN
RADIX:=8;
REPEAT GETNCTOK UNTIL CURCMD<>10

END;

IF CURCMD=32 THEN
BEGIN
N:=KOUNT[SCANDIGIT];
GETNCTOK END
ELSE IF CURCMD=76 THEN BEGIN
M:=CURCHAR;
N:=SCANNUMBER;
M:=1137+M+N;
IF(N<0) OR(N>255) OR(M>1429)
THEN BEGIN
PRINTLN(181);
ERROR;
N:=0
END;

IF M<=1264 THEN N:=EQTB[M].INT

ELSE IF M<=1392 THEN WITH
EQTB[M+1265].FOURBYTES
DO N:=((BYTE2
DIV 8)*4+(BYTE2
MOD 8))*128+BYTE3
ELSE IF M=1409 THEN N:=ROUND(EQTB[1409].PTS
)
ELSE IF M=1419 THEN
WITH EQTB[1419].FOURBYTES DO
N:=((BYTE0*128+BYTE1)*4+BYTE2)*128+BYTE3
ELSE IF M=1408 THEN
BEGIN N:=((EQTB[1408].TWOHALVES.LHWORD
DIV 8)*512+(EQTB[1408].TWOHALVES.RHWORD
DIV 8));
N:=N*2;
IF ODD(EQTB[1408].TWOHALVES.RHWORD
DIV 4)
THEN N:=N+1;
N:=N*2;
IF ODD(EQTB[1408].TWOHALVES.RHWORD)

THEN N:=N+1;
N:=N*2;
IF ODD(EQTB[1408].TWOHALVES.LHWORD)

THEN N:=N+1;
N:=N*2;
IF ODD(EQTB[1408].TWOHALVES.LHWORD
DIV 4)
THEN N:=N+1;
N:=N*2;
IF ODD(EQTB[1408].TWOHALVES.LHWORD
DIV 2)
THEN N:=N+1;
N:=N*2;
IF ODD(EQTB[1408].TWOHALVES.RHWORD
DIV 2)
THEN N:=N+1;
END
ELSE N:=EQTB[M].INT;

GETNCTOK
END
ELSE IF CURCMD>12 THEN BEGIN
BACKINPUT;
PRINTLN(182);
ERROR;
GETNCTOK
END
ELSE IF((NOT((CURTYP=12) AND
((CURVAL>=48) AND(CURVAL<=57))
)) AND((CURTYP<>12) OR(CURVAL<>46))
) THEN
BEGIN N:=CURCHAR;
GETNCTOK;
END
ELSE WHILE((CURTYP=12) AND((CURVAL>=48)
AND(CURVAL<=57)))
DO
BEGIN
N:=RADIX*N+CURCHAR-48;
NBRLENGTH:=NBRLENGTH+1;

GETNCTOK
END;

IF CURCMD<>10 THEN BACKINPUT;

SCANNUMBER:=N;
END;
FUNCTION SCANREAL: REAL;
VAR X,Y: REAL;
I: INTEGER;
BEGIN
X:=SCANNUMBER;
GETNCTOK;
IF(CURTYP=12) AND(CURVAL=46)
THEN
BEGIN
Y:=SCANNUMBER;
FOR I:=1 TO NBRLENGTH DO Y:=Y/10.0;
X:=X+Y;
END
ELSE BACKINPUT;
SCANREAL:=X;
END;
FUNCTION SCANLENGTH;
VAR X: REAL;
SIGN: REAL;
N: INTEGER;
J: INTEGER;
D: REAL;
CURFNT: INTEGER;
BEGIN
X:=SCANNUMBER;
IF NBRSIGN=45 THEN SIGN:=-1.0
ELSE SIGN:=+1.0;
GETNCTOK;
IF(CURTYP=12) AND(CURVAL=46)
THEN
BEGIN
N:=SCANNUMBER;
D:=1;
FOR J:=1 TO NBRLENGTH DO D:=D*10.0;
X:=X+N/D;
END
ELSE BACKINPUT;
IF NONMU THEN BEGIN
IF SCANSTRING(509) THEN X:=X*1000/EQTB[1420].INT
;
IF SCANSTRING(510) THEN
ELSE
IF SCANSTRING(511) THEN X:=X/0.013837
ELSE IF SCANSTRING(512) THEN
X:=X*12.0
ELSE IF SCANSTRING(513)
THEN X:=X/(0.013837*2.54)
ELSE
IF SCANSTRING(514) THEN X:=X/(0.013837*25.4)
ELSE IF SCANSTRING(515) THEN
X:=X/(72*0.013837)
ELSE IF SCANSTRING(516)
THEN X:=X/(0.013837*2540)
ELSE
IF SCANSTRING(517) THEN X:=X*(1.0/(26.6*2.54*0.013837))
ELSE IF SCANSTRING(518) THEN
X:=X*(12.0/(26.6*2.54*0.013837))
ELSE IF SCANSTRING(519) THEN
X:=X*PAGEMEM[6]
ELSE IF SCANSTRING(520)
THEN BEGIN
CURFNT:=EQTB[0].FOURBYTES.RHWORD;

IF CURFNT<=63 THEN X:=X*FMEM[PARBASE[CURFNT]+5].PTS

END
ELSE IF SCANSTRING(521) THEN BEGIN
CURFNT:=EQTB[0].FOURBYTES.RHWORD;

IF CURFONT<=63 THEN X:=X*FMEM[PARBASE[CURFNT]+4].PTS

END(* ELSE IF SCANSTRING(522) THEN
X:=X*BOXDIM(WDTH)
ELSE IF SCANSTRING(523) THEN X:=X*BOXDIM(DPTH)

ELSE IF SCANSTRING(524) THEN X:=X*BOXDIM(HGHT)
*)
ELSE BEGIN PRINTLN(525);
ERROR
END
END
ELSE IF NOT SCANSTRING(508) THEN
BEGIN PRINTLN(526);
ERROR
END;

GETNCTOK;
IF CURCMD<>10 THEN BACKINPUT;

SCANLENGTH:=X*SIGN;
END;
FUNCTION SCANGLUE: INTEGER;
VAR P: INTEGER;
BEGIN
P:=GETNODE(4);
MEM[P].TWOHALVES.RHWORD:=0;
MEM[P+1].PTS:=SCANLENGTH;
IF SCANSTRING(527) THEN MEM[P+2].PTS
:=SCANLENGTH
ELSE MEM[P+2].PTS:=0.0;
IF SCANSTRING(528) THEN MEM[P+3].PTS
:=SCANLENGTH
ELSE MEM[P+3].PTS:=0.0;
SCANGLUE:=P
END;
PROCEDURE SCANSPEC;
VAR
V: REAL;
C: INTEGER;
BEGIN
IF SCANSTRING(529) THEN
BEGIN
GETNCTOK;
IF CURCMD<>10 THEN BACKINPUT;

IF SCANSTRING(531) THEN IF MODE=-1
THEN V:=PAGEMEM[1]
ELSE V:=PAGEMEM[0]
ELSE V:=SCANLENGTH;
C:=0
END
ELSE IF(MODE=-84) AND SCANSTRING(530)
THEN
BEGIN
GETNCTOK;
IF CURCMD<>10 THEN BACKINPUT;

IF SCANSTRING(532) THEN V:=PAGEMEM[0]

ELSE V:=SCANLENGTH;
C:=2
END
ELSE BEGIN C:=1;
IF SCANSTRING(533) THEN V:=SCANLENGTH
ELSE V:=0
END;

REPEAT GETNCTOK UNTIL CURCMD<>10
;

IF CURCMD<>1 THEN
BEGIN
BACKINPUT;
BEGIN
ALIGNSTATE:=ALIGNSTATE+1;
PRINTLN(171);
ERROR
END
END;

SAVESTACK[SAVEPTR].PTS:=V;
WITH SAVESTACK[SAVEPTR+1].FOURBYTES
DO RHWORD:=C;
SAVEPTR:=SAVEPTR+2;
END;
FUNCTION SCANFONT(USINGIT: BOOLEAN):
INTEGER;
LABEL 0;

VAR F: INTEGER;
FNTNAM: ASCIISTRING;
BEGIN
WHILE TRUE DO BEGIN
GETNCTOK;
F:=CURVAL MOD 64;
IF CURCMD>=14 THEN BEGIN
BACKINPUT;
PRINTLN(534);
ERROR
END
ELSE GOTO 0
END;
0:;

GETNCTOK;
IF CURCMD<>10 THEN BACKINPUT;
PRODUCESTRING((-(F)-2),FNTNAM);
IF USINGIT AND(FNTNAM[0]=0)
THEN BEGIN
PRINTLN(535);
ERROR
END;

IF(NOT USINGIT) OR(FNTNAM[0]=0)

THEN BEGIN
REPEAT GETNCTOK UNTIL CURCMD<>10;
IF(CURCHAR<>61) AND(CURCHAR<>95)
THEN
BEGIN BACKINPUT;
PRINTLN(536);
ERROR;
END;
REPEAT GETNCTOK UNTIL CURCMD<>10;
BACKINPUT;
DEFINEFONT(F)
END;

SCANFONT:=F;
END;
PROCEDURE SCANDELIM(VAR DELIMITERS:
BYTES4);
VAR N: INTEGER;
BEGIN
GETNCTOK;
IF(CURCMD=12) AND(DELIMTABLE[CURCHAR].BYTE0
<>255)
THEN
DELIMITERS:=DELIMTABLE[CURCHAR]

ELSE IF(CURCMD=58)
AND((CURFONT MOD 8)=2) AND
(CURCHAR>=98) AND(CURCHAR<=107)

THEN
WITH DELIMITERS DO
BEGIN BYTE0:=2;
BYTE1:=CURCHAR;
BYTE2:=3;
BYTE3:=(CURCHAR+34) MOD 128 END
ELSE IF CURCMD=27 THEN WITH DELIMITERS
DO
BEGIN N:=SCANNUMBER;
BYTE3:=N MOD 128;
N:=N DIV 128;
BYTE2:=N MOD 4;
N:=N DIV 4;
BYTE1:=N MOD 128;
N:=N DIV 128;
BYTE0:=N MOD 4
END
ELSE BEGIN
BACKINPUT;
PRINTLN(537);
ERROR;
WITH DELIMITERS DO BEGIN BYTE0
:=0;
BYTE1:=0;
BYTE2:=0;
BYTE3:=0 END
END
END;
FUNCTION SCANRULESPEC: INTEGER;
LABEL 0;

VAR P: INTEGER;
BEGIN
P:=GETNODE(5);
MEM[P].TWOHALVES.BYTE2:=2;
MEM[P+1].TWOHALVES.LHWORD:=0;
IF CURCMD=47 THEN
BEGIN
MEM[P+3].PTS:=-100000.0;
MEM[P+4].PTS:=0.4;
MEM[P+2].PTS:=0.0
END
ELSE
BEGIN
MEM[P+3].PTS:=0.4;
MEM[P+4].PTS:=-100000.0;
MEM[P+2].PTS:=-100000.0
END;

WHILE TRUE DO
IF SCANSTRING(538) THEN MEM[P+3].PTS
:=SCANLENGTH
ELSE IF SCANSTRING(539) THEN MEM[P+4].PTS
:=SCANLENGTH
ELSE IF SCANSTRING(540) THEN MEM[P+2].PTS
:=SCANLENGTH
ELSE GOTO 0;
0:;

SCANRULESPEC:=P
END;
PROCEDURE PASSBLOCK;
LABEL 0;

VAR UNBAL: INTEGER;
BEGIN
UNBAL:=0;
WHILE TRUE DO BEGIN
GETTOK;
IF CURCMD=2 THEN
BEGIN UNBAL:=UNBAL-1;
IF UNBAL<=0 THEN GOTO 0
END

ELSE IF CURCMD=1 THEN UNBAL:=UNBAL+1

END;
0:;

IF UNBAL<0 THEN BEGIN ALIGNSTATE:=ALIGNSTATE+1
;

BEGIN
ALIGNSTATE:=ALIGNSTATE+1;
PRINTLN(171);
ERROR
END
END;

GETNCTOK;
IF CURCMD<>10 THEN BACKINPUT;

END;
PROCEDURE INSNUM;
LABEL 0;

VAR P,Q: INTEGER;
ROMCHAR: ASCIICODE;
J: INTEGER;
K: INTEGER;
BEGIN
IF N>=0 THEN BEGIN
P:=0;
REPEAT
Q:=GETAVAIL;
WITH MEM[Q].TWOHALVES
DO
BEGIN BYTE2:=12;
BYTE3:=(N MOD 10)+48;
LHWORD:=P END;
P:=Q;
N:=N DIV 10 UNTIL N=0
END
ELSE BEGIN
P:=25003;
J:=1;
N:=-N;
WHILE TRUE DO BEGIN
WHILE N>=ROMVAL[J] DO
BEGIN
Q:=GETAVAIL;
MEM[P].TWOHALVES.BYTE2:=11;
MEM[P].TWOHALVES.BYTE3:=ROMCHAR;
MEM[P].TWOHALVES.LHWORD:=Q;
P:=Q;
ROMCHAR:=ROMLET[J];
N:=N-ROMVAL[J]
END;

IF N=0 THEN GOTO 0;
K:=J+1+(J MOD 2);
IF(N+ROMVAL[K]>=ROMVAL[J])
THEN
BEGIN
Q:=GETAVAIL;
MEM[P].TWOHALVES.BYTE2:=11;
MEM[P].TWOHALVES.BYTE3:=ROMCHAR;
MEM[P].TWOHALVES.LHWORD:=Q;
P:=Q;
ROMCHAR:=ROMLET[K];
N:=N+ROMVAL[K]
END
ELSE J:=J+1
END;
0:
MEM[P].TWOHALVES.BYTE2:=11;
MEM[P].TWOHALVES.BYTE3:=ROMCHAR;
MEM[P].TWOHALVES.LHWORD:=0;

P:=MEM[25003].TWOHALVES.LHWORD
END;

INSLIST(P)
END;
PROCEDURE SCANCOND(B: BOOLEAN);
BEGIN
IF B THEN BEGIN
SCANLB;
NEWSAVELEVEL(3)
END
ELSE BEGIN
PASSBLOCK;
GETNCTOK;
IF CURCMD<>35 THEN
BEGIN
BACKINPUT;
PRINTLN(541);
PRINT(ESCAPECHAR);
PRINT(542);
ERROR
END;

SCANLB;
NEWSAVELEVEL(17)
END
END;
PROCEDURE IDENTER(S,COMD,LINC:
INTEGER);
VAR I: INTEGER;
CONSEQ: ASCIISTRING;
BEGIN
PRODUCESTRING(S,CONSEQ);
WITH CURINPUT DO
BEGIN I:=-1;
REPEAT I:=I+1;
BUFFER[I+1]:=CONSEQ[I]
UNTIL CONSEQ[I]=0;
CURBUF:=1;
END;
CONTROLSEQ;
WITH EQTB[HASHENTRY].FOURBYTES

DO
BEGIN BYTE1:=1;
BYTE0:=COMD;
RHWORD:=LINC END
END;
PROCEDURE SYMBENTER(S,COMD,QFONT,QCHAR:
INTEGER);
VAR I: INTEGER;
CONSEQ: ASCIISTRING;
BEGIN
PRODUCESTRING(S, CONSEQ);
WITH CURINPUT DO
BEGIN I:=-1;
REPEAT I:=I+1;
BUFFER[I+1]:=CONSEQ[I]
UNTIL CONSEQ[I]=0;
CURBUF:=1;
END;
CONTROLSEQ;
WITH EQTB[HASHENTRY].FOURBYTES

DO
BEGIN BYTE1:=1;
BYTE0:=COMD;
BYTE2:=QFONT;
BYTE3:=QCHAR END
END;
PROCEDURE INITCHARTYPES;
VAR I: INTEGER;
BEGIN
FOR I:=0 TO 127 DO EQTB[I+1137].INT
:=12;
FOR I:=65 TO 90 DO EQTB[I+1137].INT
:=11;
FOR I:=97 TO 122 DO EQTB[I+1137].INT
:=11;
EQTB[0+1137].INT:=9;
EQTB[10+1137].INT:=9;
EQTB[127+1137].INT:=9;
EQTB[9+1137].INT:=10;
EQTB[32+1137].INT:=10;
EQTB[12+1137].INT:=5;
EQTB[13+1137].INT:=5
END;
PROCEDURE INITCONSEQ;
VAR ZGLUEREF, PFGLUEREF: MEMORYWORD;
I: INTEGER;
BEGIN
IDENTER(183,81,0);
IDENTER(184,80,0);
IDENTER(185,78,0);
IDENTER(186,77,0);
IDENTER(187,76,0);
IDENTER(188,76,271);
IDENTER(189,75,0);
IDENTER(190,74,0);
HASHSEND:=HASHENTRY;
IDENTER(191,74,1);
IDENTER(192,73,0);
IDENTER(193,72,0);
IDENTER(194,70,0);
IDENTER(195,69,0);
IDENTER(196,68,2);
IDENTER(197,68,1);
IDENTER(198,62,0);
IDENTER(199,62,1);
IDENTER(47,67,0);
IDENTER(200,66,3);
IDENTER(201,66,2);
IDENTER(202,66,1);
IDENTER(203,66,0);
IDENTER(204,66,10);
IDENTER(63,66,12);
IDENTER(33,66,11);
IDENTER(60,66,13);
IDENTER(28,66,16);
IDENTER(62,66,7);
IDENTER(29,66,15);
IDENTER(59,66,9);
IDENTER(44,66,8);
IDENTER(205,65,3);
IDENTER(206,65,2);
IDENTER(207,65,1);
IDENTER(208,65,0);
IDENTER(209,64,0);
IDENTER(210,63,9);
IDENTER(211,63,8);
IDENTER(212,63,7);
IDENTER(213,63,6);
IDENTER(214,63,5);
IDENTER(215,63,4);
IDENTER(216,63,3);
IDENTER(217,63,2);
IDENTER(218,63,1);
IDENTER(219,61,13);
IDENTER(220,61,12);
WITH EQTB[1022].FOURBYTES
DO BEGIN BYTE0:=59;
RHWORD:=14 END;
WITH EQTB[1021].FOURBYTES
DO BEGIN BYTE0:=59;
RHWORD:=14 END;
WITH EQTB[1020].FOURBYTES
DO BEGIN BYTE0:=59;
RHWORD:=14 END;
WITH EQTB[1019].FOURBYTES
DO BEGIN BYTE0:=59;
RHWORD:=14 END;
WITH EQTB[1018].FOURBYTES
DO BEGIN BYTE0:=59;
RHWORD:=14 END;
IDENTER(32,59,14);
IDENTER(221,57,0);
IDENTER(222,57,1);
IDENTER(223,56,0);
SYMBENTER(42,54,2,2);
SYMBENTER(45,54,0,45);
IDENTER(224,53,1);
IDENTER(225,53,0);
IDENTER(226,53,2);
IDENTER(227,52,0);
IDENTER(228,51,0);
IDENTER(229,51,1);
IDENTER(230,50,0);
IDENTER(231,49,2);
IDENTER(232,49,0);
IDENTER(233,49,1);
IDENTER(234,48,0);
IDENTER(235,48,1);
IDENTER(236,48,2);
IDENTER(237,48,3);
IDENTER(238,47,0);
IDENTER(239,46,0);
IDENTER(240,45,100);
IDENTER(241,45,0);
IDENTER(242,45,4);
IDENTER(243,45,3);
IDENTER(244,45,2);
IDENTER(245,45,1);
IDENTER(246,44,0);
IDENTER(247,44,4);
IDENTER(248,44,3);
IDENTER(249,44,2);
IDENTER(250,44,1);
IDENTER(251,43,0);
IDENTER(252,42,0);
IDENTER(253,41,0);
IDENTER(254,40,58);
IDENTER(255,40,59);
IDENTER(256,40,60);
IDENTER(257,39,0);
IDENTER(258,38,0);
IDENTER(259,38,1);
IDENTER(260,37,0);
IDENTER(261,37,1);
IDENTER(262,36,3+84);
IDENTER(263,36,3+1);
IDENTER(264,36,0);
IDENTER(265,36,1);
IDENTER(266,36,2);
IDENTER(267,36,3);
IDENTER(268,35,0);
IDENTER(269,34,0);
IDENTER(270,82,0);
IDENTER(271,71,167);
IDENTER(272,71,84);
IDENTER(273,71,1);
IDENTER(274,33,1);
IDENTER(275,33,0);
IDENTER(276,32,0);
IDENTER(277,31,0);
IDENTER(278,30,0);
IDENTER(279,29,3);
IDENTER(280,29,2);
IDENTER(281,29,1);
IDENTER(282,29,0);
IDENTER(283,28,271);
IDENTER(284,28,0);
IDENTER(285,27,0);
IDENTER(286,26,0);
IDENTER(287,25,0);
IDENTER(288,23,0);
IDENTER(289,22,0);
IDENTER(290,21,2);
IDENTER(291,21,1);
IDENTER(292,21,0);
IDENTER(58,19,255);
EQTB[0]:=EQTB[1009+(58)];
WITH ZGLUEREF.FOURBYTES
DO BEGIN BYTE1:=1;
BYTE0:=18;
RHWORD:=16 END;
IDENTER(293,79,7);
EQTB[7]:=ZGLUEREF;
IDENTER(294,79,6);
EQTB[6]:=ZGLUEREF;
IDENTER(295,79,5);
EQTB[5]:=ZGLUEREF;
IDENTER(296,79,9);
EQTB[9]:=ZGLUEREF;
IDENTER(297,79,8);
EQTB[8]:=ZGLUEREF;
IDENTER(298,79,4);
EQTB[4]:=ZGLUEREF;
IDENTER(299,79,3);
EQTB[3]:=ZGLUEREF;
IDENTER(300,79,2);
EQTB[2]:=ZGLUEREF;
IDENTER(301,79,1);
EQTB[1]:=ZGLUEREF;
IDENTER(302,79,10);
EQTB[10]:=ZGLUEREF;
IDENTER(303,79,12);
EQTB[12]:=ZGLUEREF;
WITH PFGLUEREF.FOURBYTES
DO BEGIN BYTE1:=1;
BYTE0:=18;
RHWORD:=4 END;
IDENTER(304,79,11);
EQTB[11]:=PFGLUEREF;
IDENTER(305,79,13);
FOR I:=0 TO 9 DO EQTB[13+I]:=ZGLUEREF;
IDENTER(306,20,7);
PAGEMEM[7]:=0.0;
IDENTER(307,20,6);
PAGEMEM[6]:=1.0;
IDENTER(308,20,5);
PAGEMEM[5]:=0.0;
IDENTER(309,20,4);
PAGEMEM[4]:=10.0;
IDENTER(310,20,3);
PAGEMEM[3]:=0.0;
IDENTER(311,20,2);
PAGEMEM[2]:=3.0;
IDENTER(312,20,1);
PAGEMEM[1]:=7.0*72.0;
IDENTER(313,20,0);
PAGEMEM[0]:=4.5*72.0;
IDENTER(120,17,0);
IDENTER(314,13,0);
HASHPAR:=HASHENTRY;
IDENTER(315,5,0);
END;
PROCEDURE INITFONTCODES;
BEGIN
SYMBENTER(316,58,3+(1*8),87);
SYMBENTER(317,58,3+(1*8),86);
SYMBENTER(318,58,3+(1*8),85);
SYMBENTER(319,58,3+(1*8),84);
SYMBENTER(320,58,3+(1*8),83);
SYMBENTER(321,58,3+(1*8),82);
SYMBENTER(322,58,3+(1*8),81);
SYMBENTER(323,58,3+(1*8),80);
SYMBENTER(324,58,3+(1*8),78);
SYMBENTER(325,58,3+(1*8),76);
SYMBENTER(326,58,3+(1*8),74);
SYMBENTER(327,58,3+(1*8),72);
SYMBENTER(328,58,3+(1*8),70);
SYMBENTER(36,58,2,127);
SYMBENTER(329,58,2,126);
SYMBENTER(330,58,2,125);
SYMBENTER(64,58,2,124);
SYMBENTER(80,58,2,123);
SYMBENTER(331,58,2,122);
SYMBENTER(332,58,2,121);
SYMBENTER(333,58,2,120);
SYMBENTER(334,58,2+(2*8),121);
SYMBENTER(335,58,2+(3*8),118);
SYMBENTER(336,58,2+(2*8),117);
SYMBENTER(337,58,2+(2*8),116);
SYMBENTER(338,58,2+(1*8),115);
SYMBENTER(339,58,2,114);
SYMBENTER(35,58,2,113);
SYMBENTER(340,58,2,112);
SYMBENTER(341,58,2+(5*8),109);
SYMBENTER(342,58,2+(4*8),108);
SYMBENTER(343,58,2+(3*8),107);
SYMBENTER(344,58,2+(5*8),107);
SYMBENTER(345,58,2+(4*8),107);
SYMBENTER(124,58,2,107);
SYMBENTER(346,58,2+(3*8),106);
SYMBENTER(347,58,2+(5*8),106);
SYMBENTER(348,58,2+(4*8),106);
SYMBENTER(349,58,2+(5*8),105);
SYMBENTER(350,58,2+(4*8),104);
SYMBENTER(126,58,2+(5*8),103);
SYMBENTER(123,58,2+(4*8),102);
SYMBENTER(351,58,2+(5*8),101);
SYMBENTER(352,58,2+(4*8),100);
SYMBENTER(353,58,2+(5*8),99);
SYMBENTER(354,58,2+(4*8),98);
SYMBENTER(355,58,2+(5*8),97);
SYMBENTER(356,58,2+(4*8),96);
SYMBENTER(357,58,2+(2*8),92);
SYMBENTER(358,58,2,90);
SYMBENTER(359,58,2,89);
SYMBENTER(360,58,2,88);
SYMBENTER(361,58,2,87);
SYMBENTER(362,58,2,86);
SYMBENTER(363,58,2,85);
SYMBENTER(364,58,2,84);
SYMBENTER(365,58,2,83);
SYMBENTER(366,58,2,82);
SYMBENTER(367,58,2,81);
SYMBENTER(368,58,2,80);
SYMBENTER(369,58,2,79);
SYMBENTER(370,58,2,78);
SYMBENTER(371,58,2,77);
SYMBENTER(372,58,2,76);
SYMBENTER(373,58,2,75);
SYMBENTER(374,58,2,74);
SYMBENTER(375,58,2,73);
SYMBENTER(376,58,2,72);
SYMBENTER(377,58,2,71);
SYMBENTER(378,58,2,70);
SYMBENTER(379,58,2,69);
SYMBENTER(380,58,2,68);
SYMBENTER(381,58,2,67);
SYMBENTER(382,58,2,66);
SYMBENTER(383,58,2,65);
SYMBENTER(384,58,2+(3*8),64);
SYMBENTER(385,58,2,62);
SYMBENTER(386,58,2,61);
SYMBENTER(387,58,2,60);
SYMBENTER(388,58,2,59);
SYMBENTER(389,58,2,54);
SYMBENTER(390,58,2,52);
SYMBENTER(391,58,2+(3*8),51);
SYMBENTER(392,58,2+(3*8),50);
SYMBENTER(393,58,2,49);
SYMBENTER(394,58,2,48);
SYMBENTER(395,58,2+(3*8),47);
SYMBENTER(396,58,2+(2*8),46);
SYMBENTER(397,58,2+(2*8),45);
SYMBENTER(23,58,2+(3*8),44);
SYMBENTER(1,58,2+(3*8),43);
SYMBENTER(94,58,2+(3*8),42);
SYMBENTER(25,58,2+(3*8),41);
SYMBENTER(95,58,2+(3*8),40);
SYMBENTER(398,58,2+(3*8),39);
SYMBENTER(399,58,2+(3*8),38);
SYMBENTER(400,58,2+(3*8),37);
SYMBENTER(401,58,2+(3*8),35);
SYMBENTER(402,58,2+(3*8),34);
SYMBENTER(403,58,2+(3*8),31);
SYMBENTER(404,58,2+(3*8),30);
SYMBENTER(405,58,2+(3*8),29);
SYMBENTER(406,58,2+(3*8),25);
SYMBENTER(407,58,2+(3*8),23);
SYMBENTER(408,58,2+(3*8),22);
SYMBENTER(409,58,2+(3*8),19);
SYMBENTER(410,58,2+(3*8),18);
SYMBENTER(411,58,2,16);
SYMBENTER(412,58,2+(3*8),16);
SYMBENTER(413,58,2+(2*8),15);
SYMBENTER(414,58,2+(2*8),14);
SYMBENTER(415,58,2+(2*8),13);
SYMBENTER(416,58,2+(2*8),12);
SYMBENTER(417,58,2+(2*8),11);
SYMBENTER(418,58,2+(2*8),10);
SYMBENTER(419,58,2+(2*8),9);
SYMBENTER(420,58,2+(2*8),8);
SYMBENTER(421,58,2+(2*8),7);
SYMBENTER(422,58,2+(2*8),6);
SYMBENTER(423,58,2+(2*8),5);
SYMBENTER(424,58,2+(2*8),4);
SYMBENTER(425,58,2+(2*8),3);
SYMBENTER(426,58,2+(2*8),2);
SYMBENTER(427,58,2+(2*8),1);
SYMBENTER(428,58,1,127);
SYMBENTER(429,58,1,126);
SYMBENTER(430,58,1,125);
SYMBENTER(431,58,1,124);
SYMBENTER(432,58,1,123);
SYMBENTER(433,58,1,64);
SYMBENTER(434,58,1,37);
SYMBENTER(435,58,1,36);
SYMBENTER(436,58,1,35);
SYMBENTER(437,58,1,32);
SYMBENTER(438,58,1,31);
SYMBENTER(439,58,1,30);
SYMBENTER(440,58,1,29);
SYMBENTER(441,58,1,28);
SYMBENTER(442,58,1,27);
SYMBENTER(443,58,1,26);
SYMBENTER(444,58,1,25);
SYMBENTER(445,58,1,24);
SYMBENTER(446,58,1,23);
SYMBENTER(447,58,1,22);
SYMBENTER(448,58,1,21);
SYMBENTER(449,58,1,20);
SYMBENTER(450,58,1,19);
SYMBENTER(451,58,1,18);
SYMBENTER(452,58,1,17);
SYMBENTER(453,58,1,16);
SYMBENTER(454,58,1,15);
SYMBENTER(455,58,1,14);
SYMBENTER(456,58,1,13);
SYMBENTER(457,58,1,12);
SYMBENTER(458,58,1,11);
SYMBENTER(459,58,1,10);
SYMBENTER(460,58,1,9);
SYMBENTER(461,58,1,8);
SYMBENTER(462,58,1,7);
SYMBENTER(463,58,1,6);
SYMBENTER(464,58,1,5);
SYMBENTER(465,58,1,4);
SYMBENTER(466,58,1,3);
SYMBENTER(467,58,1,2);
SYMBENTER(468,58,1,1);
SYMBENTER(469,58,1,0);
IDENTER(79,60,64);
IDENTER(111,60,32);
IDENTER(470,60,31);
IDENTER(471,60,30);
IDENTER(472,60,29);
IDENTER(473,60,28);
IDENTER(474,60,27);
SYMBENTER(116,55,0,26);
SYMBENTER(108,55,0,25);
SYMBENTER(99,55,0,24);
SYMBENTER(97,55,0,23);
SYMBENTER(72,55,0,22);
SYMBENTER(98,55,0,21);
SYMBENTER(115,55,0,20);
SYMBENTER(34,55,0,19);
SYMBENTER(61,55,0,18);
SYMBENTER(117,55,0,17);
SYMBENTER(118,55,0,16);
SYMBENTER(65,55,0,15);
SYMBENTER(39,55,0,14);
SYMBENTER(96,55,0,13);
SYMBENTER(106,60,0,12);
SYMBENTER(105,60,0,11);
SYMBENTER(475,58,0,10);
SYMBENTER(476,58,0,9);
SYMBENTER(477,58,0,8);
SYMBENTER(478,58,0,7);
SYMBENTER(479,58,0,6);
SYMBENTER(480,58,0,5);
SYMBENTER(481,58,0,4);
SYMBENTER(482,58,0,3);
SYMBENTER(483,58,0,2);
SYMBENTER(484,58,0,1);
SYMBENTER(485,58,0,0);
END;
PROCEDURE INITHASH;
VAR N,I: INTEGER;
BEGIN
INITCHARTYPES;
FOR I:=0 TO 1136 DO EQTB[I].FOURBYTES
.BYTE0:= 83;
FOR I:=0 TO 88 DO HHEAD[I]:=1009;
FOR I:=24 TO 1009 DO HASH[I].LHWORD
:=I-1;
HASH[23].LHWORD:=1010;
INITFONTCODES;
INITCONSEQ;
INITMATHCODES;
EQTB[0+1393].INT:=255;
EQTB[1+1393].INT:=255;
EQTB[2+1393].INT:=255;
EQTB[3+1393].INT:=255;

WITH EQTB[1408].TWOHALVES DO
BEGIN
LHWORD:=4;
RHWORD:=3*8+4+2 END;

EQTB[1409].PTS:=2.0;
EQTB[1410].INT:=50;
EQTB[1411].INT:=3000;
EQTB[1412].INT:=80;
EQTB[1413].INT:=50;
EQTB[1414].INT:=95;
EQTB[1415].INT:=50;
EQTB[1416].INT:=0;
EQTB[1417].INT:=500;
EQTB[1418].INT:=700;
WITH EQTB[1419].FOURBYTES DO
BEGIN BYTE0:=2;
BYTE1:=112;
BYTE2:=3;
BYTE3:=112 END;
EQTB[1420].INT:=1000;
EQTB[1421].INT:=3000;
EQTB[1422].INT:=0;
EQTB[1423].INT:=2;
EQTB[1424].INT:=0;
EQTB[1425].INT:=50;
EQTB[1426].INT:=0;
EQTB[1427].INT:=0;
EQTB[1428].INT:=0;;
(* PRINTLN(486);
PRINTINT(1009);
PRINT(487);
PRINTINT(1008-HASH[1009].LHWORD);
PRINT(488);
N:=0;
FOR I:=0 TO 127 DO 
IF EQTB[1009+I].FOURBYTES.BYTE0<>83 THEN N:=N+1;
PRINTLN(489);
PRINTINT(N);
PRINT(490);*);

END;
PROCEDURE INITCHAR;
BEGIN
CHARTOASC['A']:=65;
CHARTOASC['B']:=66;
CHARTOASC['C']:=67;
CHARTOASC['D']:=68;
CHARTOASC['E']:=69;
CHARTOASC['F']:=70;
CHARTOASC['G']:=71;
CHARTOASC['H']:=72;
CHARTOASC['I']:=73;
CHARTOASC['J']:=74;
CHARTOASC['K']:=75;
CHARTOASC['L']:=76;
CHARTOASC['M']:=77;
CHARTOASC['N']:=78;
CHARTOASC['O']:=79;
CHARTOASC['P']:=80;
CHARTOASC['Q']:=81;
CHARTOASC['R']:=82;
CHARTOASC['S']:=83;
CHARTOASC['T']:=84;
CHARTOASC['U']:=85;
CHARTOASC['V']:=86;
CHARTOASC['W']:=87;
CHARTOASC['X']:=88;
CHARTOASC['Y']:=89;
CHARTOASC['Z']:=90;
END;
FUNCTION LEXICALORDER(WORD1,WORD2:
EXCEPTION): BOOLEAN;
LABEL 0;
VAR I:INTEGER;
BEGIN LEXICALORDER:=FALSE;
I:=1;
WHILE(WORD1[I]<>0) DO BEGIN
IF(WORD1[I]>WORD2[I]) THEN GOTO
0;
I:=I+1;

END;
LEXICALORDER:=TRUE;
0:
END;
PROCEDURE XENT(S:RAWEXCEPTION);
LABEL 50;
VAR
TEMPWORD,SWORD:EXCEPTION;
I,H,HASH,OUTPOS,INPOS:INTEGER;
CHARCHR:CHAR;
TEMPHYPH,HYPHENPATTERN:PCKDHYPHBITS;
STILLMATCHING:BOOLEAN;
BEGIN
HYPHENPATTERN:=[];
HASH:=0;
STILLMATCHING:=TRUE;
OUTPOS:=1;
INPOS:=1;
CHARCHR:=S[INPOS];

WHILE(CHARCHR<>'0') DO BEGIN
IF(CHARCHR='1') THEN HYPHENPATTERN:=HYPHENPATTERN+[OUTPOS]

ELSE IF(CHARCHR='2') THEN STILLMATCHING:=FALSE
ELSE BEGIN
IF STILLMATCHING THEN
IF(OUTPOS>12)
THEN
BEGIN
FOR I:=1 TO 16 DO PRINT(ORD(S[I]));
PRINT(491);
PRINTINT(12);
PRINT(492)
END
ELSE SWORD[OUTPOS]:=CHARTOASC[CHARCHR]
MOD 32;

OUTPOS:=OUTPOS+1
END;
INPOS:=INPOS+1;
CHARCHR:=S[INPOS]
END;

HASH:=0;
FOR I:=1 TO 7 DO HASH:=HASH*16+SWORD[I];
H:=HASH MOD 373;;
WHILE NOT(LEXICALORDER(SWORD,NULWORD))
DO
BEGIN
WHILE NOT(LEXICALORDER(EXCEPTABLE[H],SWORD))
DO H:=H-1;

IF(H=0)
THEN
H:=372
ELSE IF LEXICALORDER(SWORD,EXCEPTABLE[H])

THEN BEGIN PRINTLN(493);
FOR I:=1 TO 20 DO PRINT(CHARTOASC[S[I]]);
GOTO 50
END
ELSE BEGIN
TEMPWORD:=EXCEPTABLE[H];
TEMPHYPH:=EXCEPHYPH[H];
EXCEPTABLE[H]:=SWORD;
EXCEPHYPH[H]:=HYPHENPATTERN;
SWORD:=TEMPWORD;
HYPHENPATTERN:=TEMPHYPH
END
END;
50:
END;
PROCEDURE INITEX;
VAR EXCEPT:RAWEXCEPTION;
I:INTEGER;
BEGIN
FOR I:=1 TO 12 DO NULWORD[I]:=0;
EXCEPTABLE[0]:=NULWORD;
FOR I:=1 TO 372 DO
BEGIN EXCEPTABLE[I]:=NULWORD;
EXCEPHYPH[I]:=[]
END;

I:=1;
EXCEPT:=EXCEPTIONS[I];

WHILE(EXCEPT<>'00000000000000000000')

DO
BEGIN
XENT(EXCEPT);

I:=I+1;
EXCEPT:=EXCEPTIONS[I]
END
END;
PROCEDURE SUFFIXS(N:INTEGER;
A:OPCODE;
B:HOPERAND;
C:TRUTHX;
D:TRUTHX);
BEGIN
WITH SUFFIX[N] DO BEGIN
CODE:=A;
ALPHASET:=[];
OPRAND:=B;
TRUEX:=C;
FALSEX:=D
END
END;
PROCEDURE SUFFIXT(N:INTEGER;
ASCCHR:SHORTASCIICODE);
BEGIN
WITH SUFFIX[N] DO ALPHASET:=ALPHASET+[ASCCHR]

END;
PROCEDURE INITSUF;
BEGIN
SUFFIXS(0,0,0,0,0);
SUFFIXT(0,0);
SUFFIXT(0,1);
SUFFIXT(0,5);
SUFFIXT(0,9);
SUFFIXT(0,15);
SUFFIXT(0,21);
SUFFIXT(0,25);
SUFFIXS(1,5,0,0,0);
SUFFIXS(2,5,0,0,0);
SUFFIXS(3,0,9,34,1);
SUFFIXS(4,7,0,1,0);
SUFFIXS(5,8,0,38,0);
SUFFIXS(6,5,0,0,0);
SUFFIXS(7,0,14,60,1);
SUFFIXS(8,5,0,0,0);
SUFFIXS(9,5,0,0,0);
SUFFIXS(10,5,0,0,0);
SUFFIXS(11,5,0,0,0);
SUFFIXS(12,0,1,71,72);
SUFFIXS(13,5,0,0,0);
SUFFIXS(14,0,15,77,1);
SUFFIXS(15,5,0,0,0);
SUFFIXS(16,5,0,0,0);
SUFFIXS(17,5,0,0,0);
SUFFIXS(18,0,5,81,1);
SUFFIXS(19,8,0,85,0);
SUFFIXS(20,0,14,94,1);
SUFFIXS(21,5,0,0,0);
SUFFIXS(22,5,0,0,0);
SUFFIXS(23,5,0,0,0);
SUFFIXS(24,5,0,0,0);
SUFFIXS(25,0,12,109,98);
SUFFIXS(26,9,0,0,0);
SUFFIXS(27,4,0,0,0);
SUFFIXS(28,4,1,0,0);
SUFFIXS(29,4,2,0,0);
SUFFIXS(30,4,3,0,0);
SUFFIXS(31,6,0,0,0);
SUFFIXS(32,6,1,0,0);
SUFFIXS(33,6,2,0,0);
SUFFIXS(34,0,16,35,26);
SUFFIXS(35,0,15,36,26);
SUFFIXS(36,0,3,37,26);
SUFFIXS(37,0,19,27,26);
SUFFIXS(38,0,12,39,40);
SUFFIXS(39,0,2,41,26);
SUFFIXS(40,0,20,42,43);
SUFFIXS(41,0,1,44,26);
SUFFIXS(42,0,1,45,26);
SUFFIXS(43,0,26,46,47);
SUFFIXS(44,0,20,48,49);
SUFFIXS(45,2,50,108,26);
SUFFIXS(46,0,9,51,26);
SUFFIXS(47,0,22,52,53);
SUFFIXS(48,2,54,26,32);
SUFFIXS(49,2,107,26,31);
SUFFIXS(50,0,0,0,0);
SUFFIXT(50,3);
SUFFIXT(50,12);
SUFFIXS(51,0,12,32,26);
SUFFIXS(52,0,9,55,26);
SUFFIXS(53,0,18,56,34);
SUFFIXS(54,0,0,0,0);
SUFFIXT(54,14);
SUFFIXT(54,18);
SUFFIXS(55,0,20,27,26);
SUFFIXS(56,0,21,55,57);
SUFFIXS(57,0,5,58,26);
SUFFIXS(58,0,8,59,26);
SUFFIXS(59,0,16,37,26);
SUFFIXS(60,0,9,61,1);
SUFFIXS(61,3,3,62,110);
SUFFIXS(62,0,12,63,64);
SUFFIXS(63,2,65,27,66);
SUFFIXS(64,2,67,28,68);
SUFFIXS(65,0,0,0,0);
SUFFIXT(65,2);
SUFFIXT(65,3);
SUFFIXT(65,4);
SUFFIXT(65,6);
SUFFIXT(65,7);
SUFFIXT(65,16);
SUFFIXT(65,20);
SUFFIXT(65,26);
SUFFIXS(66,0,11,69,28);
SUFFIXS(67,0,0,0,0);
SUFFIXT(67,6);
SUFFIXT(67,19);
SUFFIXT(67,26);
SUFFIXS(68,2,0,28,70);
SUFFIXS(69,0,3,29,27);
SUFFIXS(70,1,0,27,27);
SUFFIXS(71,0,9,73,74);
SUFFIXS(72,0,21,75,1);
SUFFIXS(73,0,20,27,76);
SUFFIXS(74,0,14,14,73);
SUFFIXS(75,0,6,31,1);
SUFFIXS(76,0,3,27,1);
SUFFIXS(77,0,9,78,1);
SUFFIXS(78,2,79,80,1);
SUFFIXS(79,0,0,0,0);
SUFFIXT(79,19);
SUFFIXT(79,20);
SUFFIXS(80,8,4,27,0);
SUFFIXS(81,0,8,82,1);
SUFFIXS(82,0,16,83,1);
SUFFIXS(83,0,1,84,1);
SUFFIXS(84,0,18,27,1);
SUFFIXS(85,0,21,86,87);
SUFFIXS(86,0,15,88,4);
SUFFIXS(87,0,19,89,4);
SUFFIXS(88,0,9,90,4);
SUFFIXS(89,0,5,91,4);
SUFFIXS(90,0,3,92,4);
SUFFIXS(91,2,93,31,4);
SUFFIXS(92,0,19,27,27);
SUFFIXS(93,0,0,0,0);
SUFFIXT(93,12);
SUFFIXT(93,14);
SUFFIXS(94,0,5,95,1);
SUFFIXS(95,0,13,31,96);
SUFFIXS(96,0,4,27,97);
SUFFIXS(97,0,9,76,1);
SUFFIXS(98,0,7,99,100);
SUFFIXS(99,0,15,27,1);
SUFFIXS(100,0,18,101,81);
SUFFIXS(101,0,1,102,1);
SUFFIXS(102,0,14,103,1);
SUFFIXS(103,0,15,104,27);
SUFFIXS(104,0,9,106,28);
SUFFIXS(105,0,0,0,0);
SUFFIXT(105,2);
SUFFIXT(105,3);
SUFFIXT(105,4);
SUFFIXT(105,6);
SUFFIXT(105,7);
SUFFIXT(105,8);
SUFFIXT(105,10);
SUFFIXT(105,11);
SUFFIXT(105,12);
SUFFIXT(105,13);
SUFFIXT(105,14);
SUFFIXT(105,16);
SUFFIXT(105,17);
SUFFIXT(105,18);
SUFFIXT(105,19);
SUFFIXT(105,20);
SUFFIXT(105,22);
SUFFIXT(105,23);
SUFFIXT(105,24);
SUFFIXT(105,26);
SUFFIXS(106,6,3,0,0);
SUFFIXS(107,0,0,0,0);
SUFFIXT(107,3);
SUFFIXT(107,6);
SUFFIXT(107,7);
SUFFIXT(107,16);
SUFFIXT(107,18);
SUFFIXS(108,2,0,28,26);
SUFFIXS(109,0,2,115,31);
SUFFIXS(110,3,1,111,1);
SUFFIXS(111,2,105,112,27);
SUFFIXS(112,2,105,113,28);
SUFFIXS(113,3,0,114,1);
SUFFIXS(114,2,105,1,29);
SUFFIXS(115,0,1,44,32);
END;
PROCEDURE SCANN(N:INTEGER;
C:HOPERAND;
T:TRUTHX;
F:TRUTHX);
BEGIN
WITH PREFIX[N] DO
BEGIN
CODE:=0;
ALPHASET:=[];
TRUEX:=T;
FALSEX:=F;
OPRAND:=C
END
END;
PROCEDURE REPIET(N:INTEGER;
T:HOPERAND);
BEGIN
WITH PREFIX[N] DO
BEGIN CODE:=6;
OPRAND:=T
END
END;
PROCEDURE MARCK(N:INTEGER;
T:HOPERAND);
BEGIN
WITH PREFIX[N] DO
BEGIN CODE:=8;
OPRAND:=T
END
END;
PROCEDURE TABBLE(N: INTEGER);
BEGIN
WITH PREFIX[N] DO
BEGIN CODE:=2;
ALPHASET:=[];
END
END;
PROCEDURE PREFIXT(N:INTEGER;
ASCCHR:SHORTASCIICODE);
BEGIN WITH PREFIX[N] DO ALPHASET:=ALPHASET+[ASCCHR]

END;
PROCEDURE INITPREF;
BEGIN
PREFIX[0].CODE:=5;
PREFIX[1].CODE:=4;
SCANN(2,5,34,6);
SCANN(3,15,36,6);
SCANN(4,9,38,6);
SCANN(5,17,41,44);
PREFIX[6].CODE:=7;
TABBLE(7);
SCANN(8,1,45,47);
SCANN(9,13,27,55);
PREFIX[10].CODE:=7;
PREFIX[11].CODE:=7;
SCANN(12,5,61,6);
SCANN(13,1,63,70);
SCANN(14,15,76,6);
SCANN(15,21,77,78);
SCANN(16,19,81,6);
SCANN(17,21,85,6);
PREFIX[18].CODE:=7;
SCANN(19,5,87,89);
SCANN(20,8,97,99);
SCANN(21,14,106,1);
PREFIX[22].CODE:=7;
PREFIX[23].CODE:=7;
PREFIX[24].CODE:=7;
PREFIX[25].CODE:=4;
PREFIX[26].CODE:=7;
REPIET(27,0);
REPIET(28,1);
REPIET(29,2);
MARCK(30,0);
MARCK(31,1);
MARCK(32,2);
MARCK(33,3);
TABBLE(34);
PREFIXT(34,3);
PREFIXT(34,6);
PREFIXT(34,8);
PREFIXT(34,19);
PREFIXT(34,23);
SCANN(35,9,1,27);
SCANN(36,13,30,37);
SCANN(37,14,30,1);
SCANN(38,19,39,1);
SCANN(39,8,7,40);
SCANN(40,25,1,27);
SCANN(41,21,42,6);
SCANN(42,9,43,6);
SCANN(43,22,30,30);
SCANN(44,24,30,1);
SCANN(45,14,46,1);
SCANN(46,4,30,7);
SCANN(47,15,48,51);
SCANN(48,18,49,1);
SCANN(49,19,50,7);
SCANN(50,5,30,7);
SCANN(51,25,52,6);
SCANN(52,16,53,1);
SCANN(53,5,54,7);
SCANN(54,18,33,1);
SCANN(55,14,56,1);
SCANN(56,20,57,27);
SCANN(57,5,58,59);
SCANN(58,18,33,29);
SCANN(59,18,60,28);
SCANN(60,15,33,29);
SCANN(61,24,62,1);
SCANN(62,9,31,7);
SCANN(63,3,64,66);
SCANN(64,18,65,7);
SCANN(65,15,32,7);
SCANN(66,20,67,69);
SCANN(67,8,68,7);
SCANN(68,5,31,7);
SCANN(69,24,62,1);
SCANN(70,9,71,72);
SCANN(71,14,62,1);
SCANN(72,21,73,6);
SCANN(73,12,74,1);
SCANN(74,20,75,7);
SCANN(75,9,32,7);
SCANN(76,14,27,1);
SCANN(77,20,30,1);
SCANN(78,22,79,1);
SCANN(79,5,80,7);
SCANN(80,18,27,1);
SCANN(81,5,82,6);
SCANN(82,21,83,1);
SCANN(83,4,84,1);
SCANN(84,15,32,7);
SCANN(85,1,86,6);
SCANN(86,4,30,1);
SCANN(87,13,88,1);
SCANN(88,9,30,7);
SCANN(89,15,90,92);
SCANN(90,13,91,1);
SCANN(91,5,30,7);
SCANN(92,21,93,6);
SCANN(93,2,30,94);
SCANN(94,16,95,1);
SCANN(95,5,96,7);
SCANN(96,18,33,1);
SCANN(97,5,98,6);
SCANN(98,18,91,1);
SCANN(99,18,100,6);
SCANN(100,1,101,104);
SCANN(101,14,102,1);
SCANN(102,19,103,7);
TABBLE(103);
PREFIXT(103,1);
PREFIXT(103,6);
PREFIXT(103,7);
PREFIXT(103,12);
PREFIXT(103,13);
PREFIXT(103,16);
PREFIXT(103,19);
PREFIXT(103,22);
SCANN(104,9,105,6);
PREFIXT(103,12);
TABBLE(105);
PREFIXT(105,1);
PREFIXT(105,6);
PREFIXT(105,21);
SCANN(106,4,107,35);
SCANN(107,5,108,28);
SCANN(108,18,33,29);
END;
PROCEDURE INITB;
BEGIN
WITH BTABLE[26] DO BEGIN ALPHASET:=[];
WEAK:=0;
HCHAR:=0 END;
WITH BTABLE[27] DO BEGIN ALPHASET:=[20];
WEAK:=0;
HCHAR:=0 END;
WITH BTABLE[28] DO BEGIN ALPHASET:=[4];
WEAK:=0;
HCHAR:=0 END;
WITH BTABLE[29] DO BEGIN ALPHASET:=[16];
WEAK:=0;
HCHAR:=0 END;
WITH BTABLE[30] DO BEGIN
ALPHASET:=[4]+[7]+[19]+[20];
WEAK:=0;
HCHAR:=0
END;
WITH BTABLE[31] DO BEGIN
ALPHASET:=[7]+[13]+[14]+[20];
WEAK:=0;
HCHAR:=0
END;
WITH BTABLE[2] DO
BEGIN ALPHASET:=[12]+[18];
WEAK:=0;
HCHAR:=0 END;
WITH BTABLE[3] DO
BEGIN ALPHASET:=[12]+[18];
WEAK:=0;
HCHAR:=4 END;
WITH BTABLE[4] DO
BEGIN ALPHASET:=[7]+[18];
WEAK:=0;
HCHAR:=0 END;
WITH BTABLE[5] DO
BEGIN ALPHASET:=[12]+[18];
WEAK:=0;
HCHAR:=0 END;
WITH BTABLE[6] DO
BEGIN ALPHASET:=[12]+[18]+[20];
WEAK:=1;
HCHAR:=0
END;
WITH BTABLE[7] DO
BEGIN ALPHASET:=[12]+[18];
WEAK:=0;
HCHAR:=4 END;
WITH BTABLE[8] DO
BEGIN ALPHASET:=[];
WEAK:=0;
HCHAR:=0 END;
WITH BTABLE[9] DO BEGIN ALPHASET:=[20];
WEAK:=0;
HCHAR:=0 END;
WITH BTABLE[10] DO
BEGIN ALPHASET:=[];
WEAK:=0;
HCHAR:=0 END;
WITH BTABLE[11] DO
BEGIN ALPHASET:=[14];
WEAK:=0;
HCHAR:=0 END;
WITH BTABLE[12] DO
BEGIN ALPHASET:=[11]+[17]+[4];
WEAK:=2;
HCHAR:=0
END;
WITH BTABLE[13] DO
BEGIN ALPHASET:=[16];
WEAK:=3;
HCHAR:=0 END;
WITH BTABLE[14] DO
BEGIN
ALPHASET:=[5]+[11]+[24]+[4]+[7]+[19]+[20];
WEAK:=4;
HCHAR:=0
END;
WITH BTABLE[15] DO BEGIN ALPHASET:=[18];
WEAK:=0;
HCHAR:=0 END;
WITH BTABLE[16] DO
BEGIN ALPHASET:=[12]+[18];
WEAK:=0;
HCHAR:=1 END;
WITH BTABLE[17] DO
BEGIN ALPHASET:=[];
WEAK:=0;
HCHAR:=0 END;
WITH BTABLE[18] DO
BEGIN
ALPHASET:=[11]+[7]+[13]+[14]+[20];
WEAK:=5;
HCHAR:=0
END;
WITH BTABLE[19] DO
BEGIN
ALPHASET:=[16]+[17]+[20];
WEAK:=1;
HCHAR:=4
END;
WITH BTABLE[20] DO
BEGIN ALPHASET:=[5]+[18];
WEAK:=0;
HCHAR:=7 END;
WITH BTABLE[21] DO BEGIN ALPHASET:=[];
WEAK:=0;
HCHAR:=0 END;
WITH BTABLE[22] DO
BEGIN ALPHASET:=[];
WEAK:=0;
HCHAR:=0 END;
WITH BTABLE[23] DO
BEGIN ALPHASET:=[8]+[12]+[14]+[18];
WEAK:=0;
HCHAR:=0 END;
WITH BTABLE[24] DO BEGIN ALPHASET:=[];
WEAK:=0;
HCHAR:=0 END;
WITH BTABLE[25] DO BEGIN ALPHASET:=[18];
WEAK:=0;
HCHAR:=0 END;
END;
PROCEDURE INITD;
VAR I: INTEGER;
BEGIN
FOR I:=0 TO 127 DO WITH DELIMTABLE[I]
DO BYTE0:=255;
WITH DELIMTABLE[46] DO BEGIN BYTE0
:=0;
BYTE1:=0;
BYTE2:=0;
BYTE3:=0 END;
WITH DELIMTABLE[40] DO
BEGIN BYTE0:=0;
BYTE1:=40;
BYTE2:=3;
BYTE3:=0 END;
WITH DELIMTABLE[41] DO
BEGIN BYTE0:=0;
BYTE1:=41;
BYTE2:=3;
BYTE3:=1 END;
WITH DELIMTABLE[91] DO
BEGIN BYTE0:=0;
BYTE1:=91;
BYTE2:=3;
BYTE3:=2 END;
WITH DELIMTABLE[93] DO
BEGIN BYTE0:=0;
BYTE1:=93;
BYTE2:=3;
BYTE3:=3 END;
WITH DELIMTABLE[60] DO
BEGIN BYTE0:=2;
BYTE1:=104;
BYTE2:=3;
BYTE3:=10 END;
WITH DELIMTABLE[62] DO
BEGIN BYTE0:=2;
BYTE1:=105;
BYTE2:=3;
BYTE3:=11 END;
WITH DELIMTABLE[124] DO
BEGIN BYTE0:=2;
BYTE1:=106;
BYTE2:=3;
BYTE3:=12 END;
WITH DELIMTABLE[47] DO
BEGIN BYTE0:=0;
BYTE1:=47;
BYTE2:=3;
BYTE3:=14 END;
WITH DELIMTABLE[123] DO
BEGIN BYTE0:=2;
BYTE1:=102;
BYTE2:=3;
BYTE3:=8 END;
WITH DELIMTABLE[126] DO
BEGIN BYTE0:=2;
BYTE1:=103;
BYTE2:=3;
BYTE3:=9 END;
END;
FUNCTION CHARWD(F:INTEGER;
C: ASCIICODE):REAL;
VAR DISPLACEMENT: INTEGER;
BEGIN
DISPLACEMENT:=FONTINFO[F,C].BYTE0;
CHARWD:=FMEM[WDBASE[F]+DISPLACEMENT].PTS

END;
FUNCTION CHARHT(F:INTEGER;
C: ASCIICODE):REAL;
VAR DISPLACEMENT: INTEGER;
BEGIN
DISPLACEMENT:=FONTINFO[F,C].BYTE1
DIV 16;
CHARHT:=FMEM[HTBASE[F]+DISPLACEMENT].PTS

END;
FUNCTION CHARDP(F:INTEGER;
C: ASCIICODE):REAL;
VAR DISPLACEMENT: INTEGER;
BEGIN
DISPLACEMENT:=FONTINFO[F,C].BYTE1
MOD 16;
CHARDP:=FMEM[DPBASE[F]+DISPLACEMENT].PTS

END;
FUNCTION CHARIC(F:INTEGER;
C: ASCIICODE):REAL;
VAR DISPLACEMENT: INTEGER;
BEGIN
DISPLACEMENT:=FONTINFO[F,C].BYTE2
DIV 4;
CHARIC:=FMEM[ICBASE[F]+DISPLACEMENT].PTS

END;
PROCEDURE DEFINEFONT;
LABEL 50, 31, 0;
VAR F: INTEGER;
OLDNAM,NEWNAM: ASCIISTRING;
P: INTEGER;
J: INTEGER;
ATCLAUSE: BOOLEAN;
PSIZE: REAL;
FF: INTEGER;
BEGIN
PRODUCESTRING((-(FYL)-2),OLDNAM);
IF(PARBASE[FYL]<>0)
THEN F:=64
ELSE F:=FYL;
31:
F:=SCANFILENAME(F);
REPEAT GETNCTOK UNTIL(CURCMD<>10);
BACKINPUT;
ATCLAUSE:=SCANSTRING(494);
IF ATCLAUSE THEN PSIZE:=SCANLENGTH
ELSE PSIZE:=0.0;
IF(PSIZE<0) THEN BEGIN
PRINTLN(495);
ERROR;
PSIZE:=(0.000001*0.000001*0.00000001);
END;
IF(F<0)
THEN BEGIN BEGIN
PRINTLN(178);
PRINTFILENAME(((-(F+1))));
ERROR END;

GOTO 31;
END;
FF:=APPNDSTRING((-(F)-2),496);
IF ATCLAUSE THEN FF:=APPNDREAL((-(F)-2)
,PSIZE)
ELSE FF:=APPNDSTRING((-(F)-2)
,42);
FF:=APPNDSTRING((-(F)-2),497);
IF(OLDNAM[0]<>0)
THEN
BEGIN
PRODUCESTRING((-(F)-2),NEWNAM);
J:=0;
WHILE(OLDNAM[J]=NEWNAM[J]) AND
(OLDNAM[J]<>0) DO J:=J+1;

IF(OLDNAM[J]<>0) OR(NEWNAM[J]<>0)
THEN
BEGIN PRINTLN(498);
PRINTFILENAME(FYL);
PRINT(46);
ERROR;
GOTO 50;
END
END
ELSE IF F=64 THEN 
FF:=APPNDSTRING((-(FYL)-2),(-(F)-2));
IF(NOT(PARBASE[FYL]<>0)) THEN WHILE(F<0)
DO
BEGIN
BEGIN
PRINTLN(178);
PRINTFILENAME(((-(F+1))));
ERROR END;

F:=SCANFILENAME(FYL)
END;
CASE READFONTINFO(FYL,FONTINFO,FMEM,

WDBASE,HTBASE,DPBASE,ICBASE,LGBASE,KRBASE,EXTBASE,PARBASE,

FCKSUM,FPFB,FMAG,FPFI,FMEMPTR,PSIZE,ATCLAUSE)
OF
0:;
1: OVERFLOW(499,6400);
2: BEGIN
PRINTLN(500);
PRINT(501);
ERROR;
END;
OTHERS:
CONFUSION
END;

P:=30+FYL*4;
MEM[P].TWOHALVES.RHWORD:=50000;
MEM[P+1].PTS:= FMEM[PARBASE[FYL]+1].PTS;
MEM[P+2].PTS:= FMEM[PARBASE[FYL]+2].PTS;
MEM[P+3].PTS:= FMEM[PARBASE[FYL]+3].PTS;
50:
END;
PROCEDURE INITFNT;
LABEL 0;
VAR F,UNBAL,J: INTEGER;
IMPROPER: BOOLEAN;
CHRCODE: MEMORYWORD;
INTNUM: INTEGER;
BEGIN
FOR F:=0 TO 63 DO PARBASE[F]:=0;
FMEMPTR:=0;
INITIN;
INITSAVE;
PRINTLN(-1);
PRINTLN(502);
UNBAL:=0;
WHILE TRUE DO
BEGIN
GETNEXT;
CASE CURCMD OF
25: GOTO 0;
23: IF UNBAL=0 THEN INPUTFILE;
28: IF UNBAL=0 THEN
BEGIN
J:=CURCHAR;
INTNUM:=SCANNUMBER;
IF(INTNUM<0) OR(INTNUM>255)
THEN IMPROPER:=TRUE
ELSE IMPROPER:=FALSE;
J:=1137+J+INTNUM;
GETNCTOK;
IF CURCMD=15 THEN BEGIN
BACKINPUT;
PRINTLN(166);
ERROR;
CURCMD:=2
END;

INTNUM:=SCANNUMBER;
IF NBRSIGN=45 THEN INTNUM:=-INTNUM;
IF IMPROPER OR(J>=1429) OR((J<1265)
AND(INTNUM>14))
OR((J<=1392) AND(INTNUM>2047))

THEN BEGIN PRINTLN(503);
ERROR
END
ELSE BEGIN
IF(J>=1265) AND(J<=1392) THEN
WITH CHRCODE.FOURBYTES
DO
BEGIN BYTE2:=((INTNUM DIV 128) MOD 4)+(INTNUM
DIV 512)*8;
BYTE3:=INTNUM MOD 128;
END
ELSE IF J=1409 THEN CHRCODE.PTS:=INTNUM

ELSE IF J=1419 THEN
WITH CHRCODE.FOURBYTES DO
BEGIN BYTE3:=INTNUM MOD 128;
INTNUM:=INTNUM DIV 128;
BYTE2:=INTNUM MOD 4;
INTNUM:=INTNUM DIV 4;
BYTE1:=INTNUM MOD 128;
INTNUM:=INTNUM DIV 128;
BYTE0:=INTNUM MOD 4;
END
ELSE IF J=1408 THEN
WITH CHRCODE.TWOHALVES DO
BEGIN
LHWORD:=INTNUM DIV 32768;
INTNUM:=INTNUM MOD 32768;
RHWORD:=INTNUM DIV 64;
INTNUM:=INTNUM MOD 64;
RHWORD:=RHWORD*2+(INTNUM DIV 32);
INTNUM:=INTNUM MOD 32;
RHWORD:=RHWORD*2+(INTNUM MOD 2);
INTNUM:=INTNUM DIV 2;
LHWORD:=LHWORD*4+(INTNUM MOD 4);
INTNUM:=INTNUM DIV 4;
RHWORD:=RHWORD*2+(INTNUM DIV 2);
LHWORD:=LHWORD*2+(INTNUM MOD 2);
END
ELSE CHRCODE.INT:=INTNUM;
CHCODEDEF(J,CHRCODE)
END;
END;
1: UNBAL:=UNBAL+1;

2: UNBAL:=UNBAL-1;

72: WITH CURINPUT DO
IF BUFFER[CURBUF]<>123 THEN F:=SCANFONT(FALSE);
OTHERS:
END;

END;
0:
INITCHARTYPES;
END;
PROCEDURE INITTABLES;
BEGIN
SETTABLESIZES;
WRITESECONDMEM(MEM);
WRITEEQTB(EQTB,HASH,HHEAD,HASHPAR,HASHSEND);
WRITEHYPHENTB(READOUTVARIABLE,EXCEPTABLE,EXCEPHYPH,SUFFIX,PREFIX,BTABLE);
WRITEPAGETB(PAGEMEM);
WRITEDELIMTB(DELIMTABLE);
WRITEFMEM(FMEM,WDBASE,HTBASE,DPBASE,ICBASE,LGBASE,KRBASE,EXTBASE,PARBASE,
FONTINFO,FCKSUM,FPFB,FMAG,FPFI,FMEMPTR)

END;
BEGIN;

INITSTRINGS;
ERRCNT:=0;
DELETSALLOWED:=TRUE;
NOTNONSTOP:=TRUE;
INITSYSDEP(FOURBYTESIZE);
INITMEM;
INITIN;
INITSAVE;
INITHASH;
INITCHAR;
INITEX;
INITSUF;
INITPREF;
INITB;
INITD;
INITFNT;
INITTABLES;
NFNTS:=0;
PRINTLN(504);
FOR J:=0 TO 63 DO
IF PARBASE[J]<>0 THEN
BEGIN
PRINTLN(-1);
PRINTINT(J);
PRINT(58);
PRINTFILENAME(J);
NFNTS:=NFNTS+1;

END;
IF NFNTS=0 THEN PRINT(505)
ELSE BEGIN PRINTLN(-1);
PRINTINT(NFNTS);
PRINT(506);
END;
PRINTLN(507);
100:
END.